diff --git a/.gitignore b/.gitignore
index 443ace390c..70015e34ad 100644
--- a/.gitignore
+++ b/.gitignore
@@ -77,3 +77,5 @@ tutorial/mimic_iii_demo/data/**
 /node_modules
 cypress/screenshots/
 cypress/videos/
+
+.codex
diff --git a/.mvn/wrapper/maven-wrapper.properties b/.mvn/wrapper/maven-wrapper.properties
new file mode 100644
index 0000000000..7caaae64bb
--- /dev/null
+++ b/.mvn/wrapper/maven-wrapper.properties
@@ -0,0 +1,3 @@
+distributionType=bin
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.11/apache-maven-3.9.11-bin.zip
+wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.3.4/maven-wrapper-3.3.4.jar
diff --git a/README.md b/README.md
index c43c0101b0..832fdabb69 100644
--- a/README.md
+++ b/README.md
@@ -79,6 +79,33 @@ configurations, such as:
 
 ## Development
 
+### Backend Development
+
+#### Dropwizard backend (current production backend)
+
+From the repository root:
+
+```bash
+./mvnw -pl backend -am test
+./mvnw -pl executable -am package
+java -jar executable/target/conquery.jar standalone <path-to-config.json>
+```
+
+#### Quarkus backend (migration target)
+
+From the repository root:
+
+```bash
+./mvnw -pl backend-quarkus quarkus:dev
+```
+
+Useful endpoints while running:
+
+- `http://localhost:8090/api/ping`
+- `http://localhost:8090/api/config/frontend`
+- `http://localhost:8090/q/health`
+- `http://localhost:8090/q/swagger-ui`
+
 ### Testing
 
 #### Integration Tests
diff --git a/backend-quarkus-plugin-api/README.md b/backend-quarkus-plugin-api/README.md
new file mode 100644
index 0000000000..0c9f93fb9b
--- /dev/null
+++ b/backend-quarkus-plugin-api/README.md
@@ -0,0 +1,23 @@
+# Conquery Quarkus Plugin API
+
+This artifact is the compilation contract for third-party Conquery model plugins. A plugin should depend on
+`backend-quarkus-plugin-api` with Maven scope `provided`; it must not depend on the `backend-quarkus` application.
+
+The current stable surface covers metadata filters:
+
+- `FilterDefinition`, `AbstractFilterDefinition`, and `SingleColumnFilterDefinition` describe plugin metadata.
+- `FilterDefinitionProvider<T>` is the CDI discovery hook.
+- `FilterConversionContext` validates referenced columns without exposing backend repositories or IDs. It returns the
+  shared `dataset-model` contracts `ColumnDescriptor` and `ColumnType` rather than filter-specific column models.
+- `FilterResult` is the implementation-neutral result mapped to the backend catalog by the host.
+- `PolymorphicModelSubtype` declares the JSON/OpenAPI discriminator.
+
+Use frontend filter-value discriminator IDs such as `STRING` in `acceptedValueTypes()`. Include a Jandex index in the
+plugin JAR. The complete development, installation, reaugmentation, and test workflow is documented in
+[`backend-quarkus/README.md`](../backend-quarkus/README.md#polymorphic-model-plugins).
+
+Query filter-value, select, and condition contracts have not yet been extracted into this artifact and should be
+considered provisional.
+
+The plugin API exposes `dataset-model` transitively because dataset vocabulary is part of its public signatures. Plugin
+code imports those types from `com.bakdata.conquery.models.datasets`; it does not need a second explicit dependency.
diff --git a/backend-quarkus-plugin-api/pom.xml b/backend-quarkus-plugin-api/pom.xml
new file mode 100644
index 0000000000..2436b03911
--- /dev/null
+++ b/backend-quarkus-plugin-api/pom.xml
@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.bakdata.conquery</groupId>
+        <artifactId>parent</artifactId>
+        <version>${revision}</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+
+    <artifactId>backend-quarkus-plugin-api</artifactId>
+    <name>Conquery Quarkus Plugin API</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.bakdata.conquery</groupId>
+            <artifactId>dataset-model</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-annotations</artifactId>
+            <version>2.18.3</version>
+        </dependency>
+        <dependency>
+            <groupId>jakarta.validation</groupId>
+            <artifactId>jakarta.validation-api</artifactId>
+            <version>3.0.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.eclipse.microprofile.openapi</groupId>
+            <artifactId>microprofile-openapi-api</artifactId>
+            <version>4.0.2</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>io.smallrye</groupId>
+                <artifactId>jandex-maven-plugin</artifactId>
+                <version>3.3.1</version>
+                <executions>
+                    <execution>
+                        <id>make-index</id>
+                        <goals>
+                            <goal>jandex</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/AbstractFilterDefinition.java b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/AbstractFilterDefinition.java
new file mode 100644
index 0000000000..9d5b39eab3
--- /dev/null
+++ b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/AbstractFilterDefinition.java
@@ -0,0 +1,52 @@
+package com.bakdata.conquery.quarkus.plugin.api.filters;
+
+import com.fasterxml.jackson.annotation.JsonAlias;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+public abstract class AbstractFilterDefinition implements FilterDefinition {
+
+	@Schema(description = "Filter implementation discriminator.")
+	private String type;
+	@Schema(description = "Stable local name used to form the filter id. Falls back to the label when omitted.", pattern = "^\\w+$")
+	private String name;
+	@Schema(description = "Label displayed to users.")
+	private String label;
+	@JsonAlias("description")
+	@Schema(description = "Additional explanation displayed for the filter.")
+	private String tooltip;
+	@Schema(description = "Unit displayed with filter values.")
+	private String unit;
+	@Schema(description = "Optional input validation pattern.")
+	private String pattern;
+	@Schema(description = "Whether values may be supplied using a dropped file.")
+	private Boolean allowDropFile;
+	@Schema(description = "Default frontend value.")
+	private Object defaultValue;
+	@Schema(description = "Optional minimum frontend value.")
+	private Integer min;
+	@Schema(description = "Optional maximum frontend value.")
+	private Integer max;
+
+	public String getType() { return type; }
+	public void setType(String type) { this.type = type; }
+	public String getName() { return name; }
+	public void setName(String name) { this.name = name; }
+	public String getLabel() { return label; }
+	public void setLabel(String label) { this.label = label; }
+	public String getTooltip() { return tooltip; }
+	public void setTooltip(String tooltip) { this.tooltip = tooltip; }
+	public String getUnit() { return unit; }
+	public void setUnit(String unit) { this.unit = unit; }
+	public String getPattern() { return pattern; }
+	public void setPattern(String pattern) { this.pattern = pattern; }
+	public Boolean getAllowDropFile() { return allowDropFile; }
+	public void setAllowDropFile(Boolean allowDropFile) { this.allowDropFile = allowDropFile; }
+	public Object getDefaultValue() { return defaultValue; }
+	public void setDefaultValue(Object defaultValue) { this.defaultValue = defaultValue; }
+	public Integer getMin() { return min; }
+	public void setMin(Integer min) { this.min = min; }
+	public Integer getMax() { return max; }
+	public void setMax(Integer max) { this.max = max; }
+}
diff --git a/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/FilterConversionContext.java b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/FilterConversionContext.java
new file mode 100644
index 0000000000..9ff6caefcd
--- /dev/null
+++ b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/FilterConversionContext.java
@@ -0,0 +1,17 @@
+package com.bakdata.conquery.quarkus.plugin.api.filters;
+
+import com.bakdata.conquery.models.datasets.ColumnDescriptor;
+
+/** Host services available while converting a plugin filter definition. */
+public interface FilterConversionContext {
+
+	/** Selects a stable local ID component and reports sanitized fallbacks through the host. */
+	String idPartFromPreferredOrFallback(String preferred, String fallback, String idType, Object fallbackContext);
+
+	/**
+	 * Resolves and validates a local connector-table column.
+	 *
+	 * @throws IllegalArgumentException when the name is invalid or the column does not exist
+	 */
+	ColumnDescriptor requireColumn(String columnName);
+}
diff --git a/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/FilterDefinition.java b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/FilterDefinition.java
new file mode 100644
index 0000000000..ee8c68ef88
--- /dev/null
+++ b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/FilterDefinition.java
@@ -0,0 +1,22 @@
+package com.bakdata.conquery.quarkus.plugin.api.filters;
+
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelBase;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@JsonTypeInfo(
+		use = JsonTypeInfo.Id.NAME,
+		include = JsonTypeInfo.As.EXISTING_PROPERTY,
+		property = "type",
+		visible = true,
+		defaultImpl = UnknownFilterDefinition.class
+)
+@Schema(name = "MetadataFilterDefinition", description = "Filter definition used in connector metadata. The concrete model is selected by `type`.", discriminatorProperty = "type")
+@PolymorphicModelBase(
+		schemaName = "MetadataFilterDefinition",
+		description = "Filter definition used in connector metadata. The concrete model is selected by `type`."
+)
+public interface FilterDefinition {
+
+	String getType();
+}
diff --git a/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/FilterDefinitionProvider.java b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/FilterDefinitionProvider.java
new file mode 100644
index 0000000000..af1e072d67
--- /dev/null
+++ b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/FilterDefinitionProvider.java
@@ -0,0 +1,29 @@
+package com.bakdata.conquery.quarkus.plugin.api.filters;
+
+import java.util.Set;
+
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelTypeProvider;
+
+/**
+ * CDI discovery and conversion contract for one metadata filter model.
+ *
+ * @param <T> concrete, annotated filter definition contributed by the plugin
+ */
+public interface FilterDefinitionProvider<T extends FilterDefinition> extends PolymorphicModelTypeProvider<FilterDefinition, T> {
+
+	default String type() {
+		return typeId();
+	}
+
+	/**
+	 * Declares the frontend filter-value discriminator IDs emitted by this provider.
+	 *
+	 * @return non-empty set of registered IDs such as {@code STRING} or {@code INTEGER_RANGE}
+	 */
+	Set<String> acceptedValueTypes();
+
+	/**
+	 * Converts validated plugin metadata into an implementation-neutral filter description.
+	 */
+	FilterResult convert(FilterConversionContext context, T payload);
+}
diff --git a/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/FilterResult.java b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/FilterResult.java
new file mode 100644
index 0000000000..4e15e00c69
--- /dev/null
+++ b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/FilterResult.java
@@ -0,0 +1,32 @@
+package com.bakdata.conquery.quarkus.plugin.api.filters;
+
+import java.util.List;
+
+/**
+ * Backend-independent filter description emitted by a plugin provider.
+ *
+ * <p>Required columns are local names. The host validates them again and creates its own IDs and repository records.</p>
+ */
+public record FilterResult(
+		String name,
+		String label,
+		String valueType,
+		String unit,
+		String tooltip,
+		List<Option> options,
+		Integer min,
+		Integer max,
+		String pattern,
+		boolean allowDropFile,
+		boolean creatable,
+		Object defaultValue,
+		List<String> requiredColumns
+) {
+	public FilterResult {
+		options = options == null ? List.of() : List.copyOf(options);
+		requiredColumns = requiredColumns == null ? List.of() : List.copyOf(requiredColumns);
+	}
+
+	public record Option(String value, String label, String optionValue) {
+	}
+}
diff --git a/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/SingleColumnFilterDefinition.java b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/SingleColumnFilterDefinition.java
new file mode 100644
index 0000000000..c810c71bcf
--- /dev/null
+++ b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/SingleColumnFilterDefinition.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.quarkus.plugin.api.filters;
+
+import jakarta.validation.constraints.NotBlank;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+/** Convenience base for filter definitions referencing one local connector-table column. */
+public abstract class SingleColumnFilterDefinition extends AbstractFilterDefinition {
+
+	@NotBlank
+	@Schema(description = "Local name of a column in the connector table.", required = true, pattern = "^\\w+$")
+	private String column;
+
+	public String getColumn() {
+		return column;
+	}
+
+	public void setColumn(String column) {
+		this.column = column;
+	}
+}
diff --git a/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/UnknownFilterDefinition.java b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/UnknownFilterDefinition.java
new file mode 100644
index 0000000000..b40cc8f3a5
--- /dev/null
+++ b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/UnknownFilterDefinition.java
@@ -0,0 +1,32 @@
+package com.bakdata.conquery.quarkus.plugin.api.filters;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter;
+import com.fasterxml.jackson.annotation.JsonAnySetter;
+
+public final class UnknownFilterDefinition implements FilterDefinition {
+
+	private String type;
+	private final Map<String, Object> properties = new LinkedHashMap<>();
+
+	@Override
+	public String getType() {
+		return type;
+	}
+
+	public void setType(String type) {
+		this.type = type;
+	}
+
+	@JsonAnySetter
+	public void put(String name, Object value) {
+		properties.put(name, value);
+	}
+
+	@JsonAnyGetter
+	public Map<String, Object> properties() {
+		return Map.copyOf(properties);
+	}
+}
diff --git a/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/package-info.java b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/package-info.java
new file mode 100644
index 0000000000..33b62d9308
--- /dev/null
+++ b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/filters/package-info.java
@@ -0,0 +1,7 @@
+/**
+ * Stable compilation contracts for metadata filter plugins.
+ *
+ * <p>Plugins provide a model and CDI {@link com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinitionProvider}
+ * without depending on backend implementation classes.</p>
+ */
+package com.bakdata.conquery.quarkus.plugin.api.filters;
diff --git a/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/models/PolymorphicModelBase.java b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/models/PolymorphicModelBase.java
new file mode 100644
index 0000000000..6a2824c744
--- /dev/null
+++ b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/models/PolymorphicModelBase.java
@@ -0,0 +1,16 @@
+package com.bakdata.conquery.quarkus.plugin.api.models;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface PolymorphicModelBase {
+	String discriminator() default "type";
+	String schemaName();
+	String description() default "";
+}
diff --git a/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/models/PolymorphicModelSubtype.java b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/models/PolymorphicModelSubtype.java
new file mode 100644
index 0000000000..f16fa182c8
--- /dev/null
+++ b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/models/PolymorphicModelSubtype.java
@@ -0,0 +1,16 @@
+package com.bakdata.conquery.quarkus.plugin.api.models;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/** Declares the serialized identity of a concrete plugin model. */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface PolymorphicModelSubtype {
+	Class<?> base();
+	String id();
+}
diff --git a/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/models/PolymorphicModelTypeProvider.java b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/models/PolymorphicModelTypeProvider.java
new file mode 100644
index 0000000000..b98d7247b0
--- /dev/null
+++ b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/models/PolymorphicModelTypeProvider.java
@@ -0,0 +1,24 @@
+package com.bakdata.conquery.quarkus.plugin.api.models;
+
+public interface PolymorphicModelTypeProvider<B, T extends B> {
+
+	Class<T> modelType();
+
+	@SuppressWarnings("unchecked")
+	default Class<B> baseType() {
+		return (Class<B>) subtype().base();
+	}
+
+	default String typeId() {
+		return subtype().id();
+	}
+
+	private PolymorphicModelSubtype subtype() {
+		PolymorphicModelSubtype subtype = modelType().getAnnotation(PolymorphicModelSubtype.class);
+		if (subtype == null) {
+			throw new IllegalStateException("Polymorphic plugin model " + modelType().getName()
+					+ " must be annotated with @PolymorphicModelSubtype");
+		}
+		return subtype;
+	}
+}
diff --git a/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/models/package-info.java b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/models/package-info.java
new file mode 100644
index 0000000000..31b95816db
--- /dev/null
+++ b/backend-quarkus-plugin-api/src/main/java/com/bakdata/conquery/quarkus/plugin/api/models/package-info.java
@@ -0,0 +1,2 @@
+/** Polymorphic model annotations and provider contracts shared with plugins. */
+package com.bakdata.conquery.quarkus.plugin.api.models;
diff --git a/backend-quarkus-plugin-test/application/pom.xml b/backend-quarkus-plugin-test/application/pom.xml
new file mode 100644
index 0000000000..ddaad420f3
--- /dev/null
+++ b/backend-quarkus-plugin-test/application/pom.xml
@@ -0,0 +1,162 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.bakdata.conquery</groupId>
+        <artifactId>parent</artifactId>
+        <version>${revision}</version>
+        <relativePath>../../pom.xml</relativePath>
+    </parent>
+
+    <artifactId>backend-quarkus-plugin-test-application</artifactId>
+    <name>Conquery Quarkus Plugin Test Application</name>
+
+    <properties>
+        <quarkus.platform.group-id>io.quarkus.platform</quarkus.platform.group-id>
+        <quarkus.platform.artifact-id>quarkus-bom</quarkus.platform.artifact-id>
+        <quarkus.platform.version>3.23.4</quarkus.platform.version>
+    </properties>
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>${quarkus.platform.group-id}</groupId>
+                <artifactId>${quarkus.platform.artifact-id}</artifactId>
+                <version>${quarkus.platform.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+            <dependency>
+                <groupId>org.jboss.logging</groupId>
+                <artifactId>jboss-logging</artifactId>
+                <version>3.6.1.Final</version>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.bakdata.conquery</groupId>
+            <artifactId>backend-quarkus</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.bakdata.conquery</groupId>
+            <artifactId>backend-quarkus-plugin-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.bakdata.conquery</groupId>
+            <artifactId>backend-quarkus-test-plugin</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-junit5</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.rest-assured</groupId>
+            <artifactId>rest-assured</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>${quarkus.platform.group-id}</groupId>
+                <artifactId>quarkus-maven-plugin</artifactId>
+                <version>${quarkus.platform.version}</version>
+                <extensions>true</extensions>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>build</goal>
+                            <goal>generate-code</goal>
+                            <goal>generate-code-tests</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <systemPropertyVariables>
+                        <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
+                        <conquery.metadata.enabled>false</conquery.metadata.enabled>
+                    </systemPropertyVariables>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <version>${maven-dependency-plugin.version}</version>
+                <executions>
+                    <execution>
+                        <id>install-test-plugin-in-provider-directory</id>
+                        <phase>pre-integration-test</phase>
+                        <goals>
+                            <goal>copy</goal>
+                        </goals>
+                        <configuration>
+                            <artifactItems>
+                                <artifactItem>
+                                    <groupId>com.bakdata.conquery</groupId>
+                                    <artifactId>backend-quarkus-test-plugin</artifactId>
+                                    <version>${project.version}</version>
+                                    <type>jar</type>
+                                    <outputDirectory>${project.build.directory}/quarkus-app/providers</outputDirectory>
+                                </artifactItem>
+                            </artifactItems>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>exec-maven-plugin</artifactId>
+                <version>3.6.3</version>
+                <executions>
+                    <execution>
+                        <id>reaugment-with-test-plugin</id>
+                        <phase>pre-integration-test</phase>
+                        <goals>
+                            <goal>exec</goal>
+                        </goals>
+                        <configuration>
+                            <executable>${java.home}/bin/java</executable>
+                            <arguments>
+                                <argument>-Dquarkus.launch.rebuild=true</argument>
+                                <argument>-jar</argument>
+                                <argument>${project.build.directory}/quarkus-app/quarkus-run.jar</argument>
+                            </arguments>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <artifactId>maven-failsafe-plugin</artifactId>
+                <version>3.2.5</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>integration-test</goal>
+                            <goal>verify</goal>
+                        </goals>
+                        <configuration>
+                            <systemPropertyVariables>
+                                <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
+                                <conquery.metadata.enabled>false</conquery.metadata.enabled>
+                            </systemPropertyVariables>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/backend-quarkus-plugin-test/application/src/main/resources/application.properties b/backend-quarkus-plugin-test/application/src/main/resources/application.properties
new file mode 100644
index 0000000000..c2779936dd
--- /dev/null
+++ b/backend-quarkus-plugin-test/application/src/main/resources/application.properties
@@ -0,0 +1,10 @@
+quarkus.http.root-path=/
+quarkus.smallrye-openapi.path=/q/openapi
+quarkus.package.jar.type=mutable-jar
+quarkus.package.jar.user-providers-directory=providers
+conquery.storage.backend=IN_MEMORY
+%test.conquery.metadata.enabled=false
+
+# The backend is consumed as a library by this downstream test application.
+quarkus.index-dependency.backend.group-id=com.bakdata.conquery
+quarkus.index-dependency.backend.artifact-id=backend-quarkus
diff --git a/backend-quarkus-plugin-test/application/src/test/java/com/bakdata/conquery/quarkus/testplugin/it/PluginIntegrationTest.java b/backend-quarkus-plugin-test/application/src/test/java/com/bakdata/conquery/quarkus/testplugin/it/PluginIntegrationTest.java
new file mode 100644
index 0000000000..9984c3b3a5
--- /dev/null
+++ b/backend-quarkus-plugin-test/application/src/test/java/com/bakdata/conquery/quarkus/testplugin/it/PluginIntegrationTest.java
@@ -0,0 +1,107 @@
+package com.bakdata.conquery.quarkus.testplugin.it;
+
+import static io.restassured.RestAssured.given;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.filters.FilterDefinitionAssembler;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.quarkus.ids.ConceptId;
+import com.bakdata.conquery.quarkus.ids.ConnectorId;
+import com.bakdata.conquery.quarkus.ids.DatasetId;
+import com.bakdata.conquery.quarkus.ids.TableId;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelRegistry;
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import com.bakdata.conquery.quarkus.testplugin.PrefixFilterDefinition;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.quarkus.test.junit.QuarkusTest;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.Test;
+
+@QuarkusTest
+class PluginIntegrationTest {
+
+	@Inject
+	ObjectMapper objectMapper;
+
+	@Inject
+	PolymorphicModelRegistry modelRegistry;
+
+	@Inject
+	FilterDefinitionAssembler assembler;
+
+	@Test
+	void discoversPluginProviderAndUsesItEndToEnd() throws Exception {
+		FilterDefinition definition = objectMapper.readValue("""
+				{"type":"PLUGIN_PREFIX","name":"plugin_filter","label":"Plugin filter","column":"code","prefix":"ABC"}
+				""", FilterDefinition.class);
+
+		PrefixFilterDefinition pluginDefinition = assertInstanceOf(PrefixFilterDefinition.class, definition);
+		assertEquals("ABC", pluginDefinition.getPrefix());
+		assertTrue(modelRegistry.find(FilterDefinition.class, "PLUGIN_PREFIX").isPresent());
+
+		DatasetId datasetId = new DatasetId("plugin-test");
+		TableId tableId = new TableId(datasetId, "events");
+		ConceptId conceptId = new ConceptId(datasetId, List.of("plugin-concept"));
+		ConnectorId connectorId = new ConnectorId(conceptId, "plugin-connector");
+		ColumnId columnId = new ColumnId(tableId, "code");
+		DatasetCatalogRepository.TableRecord table = new DatasetCatalogRepository.TableRecord(
+				tableId,
+				"Events",
+				List.of(new DatasetCatalogRepository.ColumnRecord(columnId, "Code", ColumnType.STRING, null)),
+				columnId
+		);
+
+		DatasetCatalogRepository.Filter filter = assembler.assemble(
+				connectorId,
+				tableId,
+				table,
+				List.of(definition),
+				(idType, context, fallbackValue, sanitized) -> { },
+				true
+		).getFirst();
+
+		assertEquals("plugin_filter", filter.id().name());
+		assertEquals("STRING", filter.type());
+		assertEquals("ABC.*", filter.pattern());
+		assertEquals("ABC", filter.defaultValue());
+		assertEquals(List.of(columnId), filter.requiredColumns());
+	}
+
+	@Test
+	void exposesPluginModelInOpenApi() throws Exception {
+		String document = given()
+				.queryParam("format", "json")
+				.when().get("/q/openapi")
+				.then().statusCode(200)
+				.extract().asString();
+		JsonNode schemas = objectMapper.readTree(document).path("components").path("schemas");
+
+		assertEquals(
+				"#/components/schemas/MetadataPluginPrefixFilter",
+				schemas.path("MetadataFilterDefinition").path("discriminator").path("mapping").path("PLUGIN_PREFIX").asText()
+		);
+		JsonNode pluginSchema = schemas.path("MetadataPluginPrefixFilter");
+		assertEquals("PLUGIN_PREFIX", pluginSchema.path("properties").path("type").path("const").asText());
+		assertTrue(hasProperty(pluginSchema, "column"));
+		assertTrue(hasProperty(pluginSchema, "prefix"));
+	}
+
+	private boolean hasProperty(JsonNode schema, String name) {
+		if (!schema.path("properties").path(name).isMissingNode()) {
+			return true;
+		}
+		for (JsonNode parent : schema.path("allOf")) {
+			if (hasProperty(parent, name)) {
+				return true;
+			}
+		}
+		return false;
+	}
+}
diff --git a/backend-quarkus-plugin-test/application/src/test/java/com/bakdata/conquery/quarkus/testplugin/it/PluginProviderDirectoryIT.java b/backend-quarkus-plugin-test/application/src/test/java/com/bakdata/conquery/quarkus/testplugin/it/PluginProviderDirectoryIT.java
new file mode 100644
index 0000000000..7a7e3c316b
--- /dev/null
+++ b/backend-quarkus-plugin-test/application/src/test/java/com/bakdata/conquery/quarkus/testplugin/it/PluginProviderDirectoryIT.java
@@ -0,0 +1,28 @@
+package com.bakdata.conquery.quarkus.testplugin.it;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.equalTo;
+
+import io.quarkus.test.junit.QuarkusIntegrationTest;
+import org.junit.jupiter.api.Test;
+
+@QuarkusIntegrationTest
+class PluginProviderDirectoryIT {
+
+	@Test
+	void exposesPluginInstalledThroughUserProviderDirectory() {
+		given()
+				.queryParam("format", "json")
+				.when().get("/q/openapi")
+				.then()
+				.statusCode(200)
+				.body(
+						"components.schemas.MetadataFilterDefinition.discriminator.mapping.PLUGIN_PREFIX",
+						equalTo("#/components/schemas/MetadataPluginPrefixFilter")
+				)
+				.body(
+						"components.schemas.MetadataPluginPrefixFilter.properties.type.const",
+						equalTo("PLUGIN_PREFIX")
+				);
+	}
+}
diff --git a/backend-quarkus-plugin-test/plugin/pom.xml b/backend-quarkus-plugin-test/plugin/pom.xml
new file mode 100644
index 0000000000..31f95a65f6
--- /dev/null
+++ b/backend-quarkus-plugin-test/plugin/pom.xml
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.bakdata.conquery</groupId>
+        <artifactId>parent</artifactId>
+        <version>${revision}</version>
+        <relativePath>../../pom.xml</relativePath>
+    </parent>
+
+    <artifactId>backend-quarkus-test-plugin</artifactId>
+    <packaging>jar</packaging>
+    <name>Conquery Quarkus Test Plugin</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.bakdata.conquery</groupId>
+            <artifactId>backend-quarkus-plugin-api</artifactId>
+            <version>${project.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>jakarta.enterprise</groupId>
+            <artifactId>jakarta.enterprise.cdi-api</artifactId>
+            <version>4.1.0</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>jakarta.validation</groupId>
+            <artifactId>jakarta.validation-api</artifactId>
+            <version>3.0.2</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.eclipse.microprofile.openapi</groupId>
+            <artifactId>microprofile-openapi-api</artifactId>
+            <version>4.0.2</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>io.smallrye</groupId>
+                <artifactId>jandex-maven-plugin</artifactId>
+                <version>3.3.1</version>
+                <executions>
+                    <execution>
+                        <id>make-index</id>
+                        <goals>
+                            <goal>jandex</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/backend-quarkus-plugin-test/plugin/src/main/java/com/bakdata/conquery/quarkus/testplugin/PrefixFilterDefinition.java b/backend-quarkus-plugin-test/plugin/src/main/java/com/bakdata/conquery/quarkus/testplugin/PrefixFilterDefinition.java
new file mode 100644
index 0000000000..164578313f
--- /dev/null
+++ b/backend-quarkus-plugin-test/plugin/src/main/java/com/bakdata/conquery/quarkus/testplugin/PrefixFilterDefinition.java
@@ -0,0 +1,24 @@
+package com.bakdata.conquery.quarkus.testplugin;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.SingleColumnFilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotBlank;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataPluginPrefixFilter", description = "Filter contributed by the separate test plugin JAR.")
+@PolymorphicModelSubtype(base = FilterDefinition.class, id = "PLUGIN_PREFIX")
+public final class PrefixFilterDefinition extends SingleColumnFilterDefinition {
+
+	@NotBlank
+	@Schema(description = "Prefix suggested by the plugin.", required = true)
+	private String prefix;
+
+	public String getPrefix() {
+		return prefix;
+	}
+
+	public void setPrefix(String prefix) {
+		this.prefix = prefix;
+	}
+}
diff --git a/backend-quarkus-plugin-test/plugin/src/main/java/com/bakdata/conquery/quarkus/testplugin/PrefixFilterProvider.java b/backend-quarkus-plugin-test/plugin/src/main/java/com/bakdata/conquery/quarkus/testplugin/PrefixFilterProvider.java
new file mode 100644
index 0000000000..de7a8d8864
--- /dev/null
+++ b/backend-quarkus-plugin-test/plugin/src/main/java/com/bakdata/conquery/quarkus/testplugin/PrefixFilterProvider.java
@@ -0,0 +1,45 @@
+package com.bakdata.conquery.quarkus.testplugin;
+
+import java.util.List;
+import java.util.Set;
+
+import com.bakdata.conquery.models.datasets.ColumnDescriptor;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinitionProvider;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class PrefixFilterProvider implements FilterDefinitionProvider<PrefixFilterDefinition> {
+
+	@Override
+	public Class<PrefixFilterDefinition> modelType() {
+		return PrefixFilterDefinition.class;
+	}
+
+	@Override
+	public Set<String> acceptedValueTypes() {
+		return Set.of("STRING");
+	}
+
+	@Override
+	public FilterResult convert(FilterConversionContext context, PrefixFilterDefinition payload) {
+		ColumnDescriptor column = context.requireColumn(payload.getColumn());
+		String name = context.idPartFromPreferredOrFallback(payload.getName(), payload.getLabel(), "filter id", type());
+		return new FilterResult(
+				name,
+				payload.getLabel(),
+				"STRING",
+				payload.getUnit(),
+				payload.getTooltip(),
+				List.of(),
+				null,
+				null,
+				payload.getPrefix() + ".*",
+				false,
+				false,
+				payload.getPrefix(),
+				List.of(column.name())
+		);
+	}
+}
diff --git a/backend-quarkus-plugin-test/pom.xml b/backend-quarkus-plugin-test/pom.xml
new file mode 100644
index 0000000000..9660a50a4e
--- /dev/null
+++ b/backend-quarkus-plugin-test/pom.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.bakdata.conquery</groupId>
+        <artifactId>parent</artifactId>
+        <version>${revision}</version>
+    </parent>
+
+    <artifactId>backend-quarkus-plugin-test</artifactId>
+    <packaging>pom</packaging>
+    <name>Conquery Quarkus Plugin Integration Test</name>
+
+    <modules>
+        <module>plugin</module>
+        <module>application</module>
+    </modules>
+</project>
diff --git a/backend-quarkus/README.md b/backend-quarkus/README.md
new file mode 100644
index 0000000000..22083f84a5
--- /dev/null
+++ b/backend-quarkus/README.md
@@ -0,0 +1,319 @@
+# Conquery Quarkus Backend
+
+This module is the migration target for replacing the Dropwizard backend with Quarkus in small, safe increments.
+
+## Current state
+
+- Maven module: `backend-quarkus`
+- Quarkus REST runtime with JSON support
+- Health and OpenAPI extensions
+- Dataset, concept, filter, form-config, query, frontend-config, and user API slices
+- In-memory and Xodus-backed manager metadata storage
+- Read-only folder-based ingestion of dataset definitions into a rich in-memory model
+- Extensible polymorphic metadata and query models
+
+The Dropwizard `backend` remains the production backend. Entity-query execution and some compatibility slices are not
+implemented in Quarkus yet.
+
+## Run locally
+
+From repository root:
+
+```bash
+./mvnw -pl backend-quarkus quarkus:dev
+```
+
+Default port is `8090`.
+
+### Ingest generated dataset metadata folders at startup
+
+You can mount generated metadata folders (for example `.../gen/demo`) into the container and let the backend ingest
+them during boot:
+
+```properties
+conquery.metadata.enabled=true
+conquery.metadata.root-path=/data/gen
+conquery.metadata.folders[0]=demo
+```
+
+This reads `conceptTrees/*.concept.json` and `tables/*.table.json` from each configured folder and loads them as
+dataset metadata. Dataset definitions are derived state: they are rebuilt on every application start and are not
+persisted in Xodus. Change the source metadata and restart the application to update them.
+
+Each `dataset.json` can select a Quarkus named datasource. If omitted, `dataSource` defaults to the dataset id:
+
+```json
+{
+  "id": "claims",
+  "label": "Claims",
+  "dataSource": "analytics"
+}
+```
+
+The loaded repository retains the complete typed filter, select, and condition definitions. REST resources map this
+internal model to their dedicated response records, while query planning can use the same repository without loading
+or persisting a second dataset representation.
+
+### Configure SQL datasources
+
+SQL execution is disabled until `conquery.sql.enabled=true`. Dataset datasource names refer to standard Quarkus named
+JDBC datasources. HANA and ClickHouse use custom JDBC drivers and therefore use `db-kind=other`:
+
+```properties
+conquery.sql.enabled=true
+conquery.sql.datasources.analytics.dialect=CLICKHOUSE
+
+quarkus.datasource.analytics.db-kind=other
+quarkus.datasource.analytics.jdbc.driver=com.clickhouse.jdbc.ClickHouseDriver
+quarkus.datasource.analytics.jdbc.url=${ANALYTICS_JDBC_URL}
+quarkus.datasource.analytics.jdbc.transactions=disabled
+quarkus.datasource.analytics.username=${ANALYTICS_USER}
+quarkus.datasource.analytics.password=${ANALYTICS_PASSWORD}
+```
+
+For HANA, set `conquery.sql.datasources.<name>.dialect=HANA` and use `com.sap.db.jdbc.Driver`. Quarkus manages the
+Agroal pools and contributes their readiness checks through SmallRye Health. Datasource names and `db-kind` are
+build-time configuration; URLs, credentials, activation, and pool sizing can remain runtime configuration. When SQL
+is enabled, startup fails if a loaded dataset references a datasource without Conquery dialect metadata or without a
+matching Quarkus named datasource.
+
+### Concept JSON migration helpers
+
+Some Dropwizard concept metadata still uses connector column references in the old `table.column` form. The migration
+helper `scripts/normalize_concept_connector_columns.py` rewrites those references for the Quarkus metadata loader:
+
+- connector `"column": "table.column"` becomes `"table": "table", "column": "column"`
+- filter `"column": "table.column"` becomes `"column": "column"`
+- validity-date `column`, `startColumn`, and `endColumn` references become local column names
+
+Run it from the repository root:
+
+```bash
+python3 scripts/normalize_concept_connector_columns.py path/to/*.concept.json
+```
+
+Use `--dry-run` first to see how many connector, filter, connector-select, and validity-date columns would be changed. Select fields
+covered by the script are `column`, `startColumn`, `endColumn`, `subtractColumn`, `distinctByColumn`, `distinctBy`, and
+the column values in `flags`. This script is intended to grow with additional concept metadata migration steps as they
+become necessary.
+
+## Polymorphic model plugins
+
+Metadata models are code-first. Java model classes, Jackson annotations, Bean Validation constraints, and OpenAPI
+`@Schema` annotations are used both for loading metadata files and for generating their schemas. Registered model
+families are exposed in the OpenAPI document at `GET /q/openapi` as `oneOf` schemas with discriminator mappings.
+
+These plugins are ordinary JAR libraries containing CDI beans. They are not full Quarkus extensions and they are not
+hot-loaded. The backend is packaged as a Quarkus mutable JAR with an official user-provider directory named
+`providers`. A plugin becomes part of the application only when Quarkus reaugmentation runs after the JAR was placed
+in that directory. This is the same mechanism for a local unpacked distribution and for a container image. See the
+Quarkus [reaugmentation guide](https://quarkus.io/guides/reaugmentation) for the underlying packaging mechanism.
+
+This mechanism is separate from the Dropwizard `plugins` array in `config.json`. Entries such as `FORM_BACKEND` configure
+runtime integrations; they do not install polymorphic model implementations.
+
+### Supported extension points
+
+| Model family | Model base | Provider bean | Contract |
+| --- | --- | --- | --- |
+| Metadata filters | `FilterDefinition` | `FilterDefinitionProvider<T>` | Stable plugin API |
+| Query filter values | `FilterValue` | `FilterValueProvider<T>` | Provisional backend API |
+| Connector selects | `SelectDefinition` | `SelectDefinitionProvider<T>` | Provisional backend API |
+| Concept-level selects | `ConceptSelectDefinition` | `ConceptSelectDefinitionProvider<T>` | Provisional backend API |
+| Concept-tree conditions | `ConceptCondition` | `ConceptConditionProvider<T>` | Provisional backend API |
+
+A metadata filter plugin provides:
+
+1. A concrete class implementing `FilterDefinition`, annotated with OpenAPI `@Schema` and
+   `@PolymorphicModelSubtype(base = FilterDefinition.class, id = "...")`.
+2. A CDI bean implementing `FilterDefinitionProvider<T>` for its model class, conversion, and integrity validation.
+3. The filter value model types accepted by that provider. Each model type needs a registered `FilterValueProvider<T>`.
+
+Connector selects use the equivalent `SelectDefinition` and `SelectDefinitionProvider<T>` extension points. Concept-level
+selects form a separate family with `ConceptSelectDefinition` and `ConceptSelectDefinitionProvider<T>`. Unknown types
+fail startup by default; `conquery.metadata.strict-filter-types` and
+`conquery.metadata.strict-select-types` can independently switch their family to warning-and-skip behavior.
+
+Concept-tree conditions use `ConceptCondition` and `ConceptConditionProvider<T>`. Because skipping a condition would
+change the meaning of a concept node, unknown condition types always fail metadata validation. The built-in condition
+types are `EQUAL`, `PREFIX_LIST`, `PREFIX_RANGE`, `COLUMN_EQUAL`, `PRESENT`, `AND`, `OR`, and `NOT`. The old `GROOVY`
+condition is intentionally not registered because script execution requires a separate security and runtime decision.
+
+Query filter values use the separate `FilterValue` and `FilterValueProvider<T>` family. Their discriminator ids may
+overlap metadata filter definitions (for example `SELECT`) because polymorphic registrations are scoped by base type.
+Filter providers declare their accepted `FilterValue` model classes through `acceptedValueTypes()`. Startup verifies
+that each declared model has a registered value provider, and metadata conversion verifies the emitted value type.
+Entity-query execution is intentionally not implemented yet. The filter value and entity-history API models are kept,
+but the entity-history and entity-resolution endpoints return `501 Not Implemented` until their business semantics are migrated.
+
+The generic `PolymorphicModelRegistry` validates duplicate type ids and base/model compatibility at startup. Its
+registrations are also installed into Jackson and projected into OpenAPI. Extension JARs must be discoverable by
+Quarkus bean and Jandex indexing so their provider and annotated model class are available during application assembly.
+
+### Develop a plugin JAR
+
+Use a separate Maven project with Java 21. Filter plugins compile against the dedicated plugin API, not the backend
+application. Keep the dependency `provided`, because the host distribution supplies the API classes:
+
+```xml
+<dependency>
+    <groupId>com.bakdata.conquery</groupId>
+    <artifactId>backend-quarkus-plugin-api</artifactId>
+    <version>${conquery.version}</version>
+    <scope>provided</scope>
+</dependency>
+```
+
+The API artifact must be available from a Maven repository. For local development from this repository, install it
+first:
+
+```bash
+./mvnw -pl backend-quarkus-plugin-api -am install -DskipTests
+```
+
+Quarkus discovers the plugin's CDI beans and OpenAPI models from its build-time index. Generate
+`META-INF/jandex.idx` in the plugin JAR:
+
+```xml
+<plugin>
+    <groupId>io.smallrye</groupId>
+    <artifactId>jandex-maven-plugin</artifactId>
+    <version>3.3.1</version>
+    <executions>
+        <execution>
+            <id>make-index</id>
+            <goals>
+                <goal>jandex</goal>
+            </goals>
+        </execution>
+    </executions>
+</plugin>
+```
+
+For each implementation:
+
+1. Choose a discriminator unique within its model family. IDs may be reused across different families.
+2. Implement a concrete model with public Jackson-accessible properties.
+3. Add `@Schema(name = "...")` and `@PolymorphicModelSubtype(base = ..., id = "...")` to the model.
+4. Implement the matching provider interface and annotate the provider with a CDI scope such as `@ApplicationScoped`.
+5. Return the accepted frontend value discriminator IDs from `acceptedValueTypes()`, for example `Set.of("STRING")`.
+6. Convert the model into a plugin API `FilterResult`. Use `FilterConversionContext.requireColumn()` to validate and
+   inspect referenced columns through the `dataset-model` contracts `ColumnDescriptor` and `ColumnType`. Do not
+   construct backend IDs or repository records in a plugin.
+7. Run `mvn verify` and confirm the built JAR contains `META-INF/jandex.idx`.
+
+The filter contract is contained in `backend-quarkus-plugin-api` under `com.bakdata.conquery.quarkus.plugin.api`. It
+contains the definition bases, provider interface, conversion context/result, and plugin polymorphism annotations.
+Shared column descriptors live in the dependency-free `dataset-model` artifact under
+`com.bakdata.conquery.models.datasets`. Backend IDs, storage repositories, and implementation DTOs are intentionally
+excluded. Query filter-value, select, and condition extension contracts are still provisional and remain in
+`backend-quarkus`; extract them into this API before treating them as compatibility-stable third-party extension
+points.
+
+The executable example is in `backend-quarkus-plugin-test/plugin`. Its `PLUGIN_PREFIX` filter deliberately lives in a
+separate JAR and has no dependency on the backend application artifact.
+
+### Install a plugin in a distribution
+
+First build the mutable application distribution:
+
+```bash
+./mvnw -pl backend-quarkus -am package
+```
+
+Copy the plugin and any of its dependencies that are not already supplied by Conquery into the generated provider
+directory:
+
+```bash
+cp my-conquery-plugin.jar backend-quarkus/target/quarkus-app/providers/
+```
+
+On PowerShell, use:
+
+```powershell
+Copy-Item my-conquery-plugin.jar backend-quarkus/target/quarkus-app/providers/
+```
+
+Reaugment the distribution after every plugin addition, replacement, or removal:
+
+```bash
+java -Dquarkus.launch.rebuild=true -jar backend-quarkus/target/quarkus-app/quarkus-run.jar
+```
+
+Reaugmentation performs the Quarkus build-time discovery and then exits; it does not start the server. Start the
+result normally:
+
+```bash
+java -jar backend-quarkus/target/quarkus-app/quarkus-run.jar
+```
+
+Do not add or change provider JARs after the final reaugmentation. Such changes are not part of CDI, Jackson, or the
+generated OpenAPI document. Treat the reaugmented `quarkus-app` directory as one immutable deployment artifact.
+
+For container packaging, use the same sequence while building the image: copy the base `quarkus-app` distribution,
+copy plugin JARs into `quarkus-app/providers/`, run the reaugmentation command in a build layer, and copy the resulting
+directory into the final runtime image. The running container only needs the normal start command; it must not install
+or reaugment plugins at startup. Mutable JAR reaugmentation is a JVM packaging feature and does not apply to native
+executables.
+
+For development with `quarkus:dev`, add the plugin as a Maven dependency of `backend-quarkus`; the provider-directory
+workflow exercises the packaged distribution.
+
+### Verify the plugin contract
+
+The repository contains a downstream test application because testing the plugin inside `backend-quarkus` would create
+a Maven dependency cycle. The reactor order is:
+
+```text
+dataset-model -> backend-quarkus-plugin-api -> backend-quarkus -> backend-quarkus-test-plugin -> backend-quarkus-plugin-test-application
+```
+
+Run the fast application-level contract from the repository root:
+
+```bash
+./mvnw -pl backend-quarkus-plugin-test/application -am test
+```
+
+`PluginIntegrationTest` verifies all externally observable parts of the contract:
+
+- CDI discovers the provider from the indexed plugin dependency.
+- Jackson deserializes the plugin discriminator into the plugin model.
+- The real filter assembler invokes the plugin provider and validates its accepted filter-value type.
+- `/q/openapi` contains the plugin schema and discriminator mapping.
+
+Run the packaged-distribution contract with:
+
+```bash
+./mvnw -pl backend-quarkus-plugin-test/application -am verify
+```
+
+`PluginProviderDirectoryIT` packages the application without the plugin on its runtime dependency graph, copies the
+real test-plugin JAR into `quarkus-app/providers/`, invokes Quarkus reaugmentation, starts the packaged application in
+the production profile, and checks the plugin discriminator and schema through `/q/openapi`. This test covers the same
+installation boundary used by a customized container image or a local distribution.
+
+When adding another extension point or changing discovery, update the sample plugin and this integration test. A unit
+test that manually constructs a provider is insufficient because it does not exercise Quarkus dependency indexing or
+CDI discovery. The fast test gives focused failures; the packaged integration test is the authoritative proof of the
+installation mechanism.
+
+## Migration strategy
+
+1. Keep `backend` (Dropwizard) running while we port feature slices.
+2. Move framework-neutral logic first (services, models, utility layers).
+3. Port HTTP resources incrementally:
+   - `resources/api/*`
+   - `resources/admin/rest/*`
+4. Replace Dropwizard-specific primitives with Quarkus equivalents:
+   - `@Auth` + Dropwizard Auth -> CDI + Quarkus Security/JAX-RS filters
+   - Dropwizard `Task` -> scheduled jobs/admin endpoints
+   - `Managed` lifecycle hooks -> Quarkus startup/shutdown events
+   - Freemarker views -> keep server-side templates via Quarkus Qute/Freemarker extension or move to frontend
+5. Port CLI commands (`ShardCommand`, `PreprocessorCommand`, etc.) to Quarkus CLI/Picocli entrypoints.
+
+## Next migration slices
+
+- Introduce shared core module for code that should be reused by both runtimes.
+- Add compatibility tests that hit both old and new endpoints for parity.
+- Implement entity-query execution and ID resolution against dataset contents.
+- Complete concept search, statistics, and remaining frontend metadata compatibility.
diff --git a/backend-quarkus/pom.xml b/backend-quarkus/pom.xml
new file mode 100644
index 0000000000..6bd9d086fb
--- /dev/null
+++ b/backend-quarkus/pom.xml
@@ -0,0 +1,171 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.bakdata.conquery</groupId>
+        <artifactId>parent</artifactId>
+        <version>${revision}</version>
+    </parent>
+
+    <artifactId>backend-quarkus</artifactId>
+    <name>Conquery Backend (Quarkus)</name>
+
+    <properties>
+        <quarkus.platform.group-id>io.quarkus.platform</quarkus.platform.group-id>
+        <quarkus.platform.artifact-id>quarkus-bom</quarkus.platform.artifact-id>
+        <quarkus.platform.version>3.23.4</quarkus.platform.version>
+        <skipITs>true</skipITs>
+    </properties>
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>${quarkus.platform.group-id}</groupId>
+                <artifactId>${quarkus.platform.artifact-id}</artifactId>
+                <version>${quarkus.platform.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+            <dependency>
+                <groupId>org.jboss.logging</groupId>
+                <artifactId>jboss-logging</artifactId>
+                <version>3.6.1.Final</version>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.bakdata.conquery</groupId>
+            <artifactId>dataset-model</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.bakdata.conquery</groupId>
+            <artifactId>backend-quarkus-plugin-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-arc</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-rest</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-rest-jackson</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-smallrye-openapi</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-info</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-smallrye-health</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-agroal</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.clickhouse</groupId>
+            <artifactId>clickhouse-jdbc</artifactId>
+            <version>0.9.8</version>
+            <classifier>all</classifier>
+        </dependency>
+        <dependency>
+            <groupId>com.sap.cloud.db.jdbc</groupId>
+            <artifactId>ngdbc</artifactId>
+            <version>2.17.10</version>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-hibernate-validator</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.xodus</groupId>
+            <artifactId>xodus-environment</artifactId>
+            <version>1.3.232</version>
+        </dependency>
+
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-junit5</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-test-security</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.rest-assured</groupId>
+            <artifactId>rest-assured</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>jakarta.validation</groupId>
+            <artifactId>jakarta.validation-api</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>${quarkus.platform.group-id}</groupId>
+                <artifactId>quarkus-maven-plugin</artifactId>
+                <version>${quarkus.platform.version}</version>
+                <extensions>true</extensions>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>build</goal>
+                            <goal>generate-code</goal>
+                            <goal>generate-code-tests</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <systemPropertyVariables>
+                        <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
+                    </systemPropertyVariables>
+                </configuration>
+            </plugin>
+            <plugin>
+                <artifactId>maven-failsafe-plugin</artifactId>
+                <version>3.2.5</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>integration-test</goal>
+                            <goal>verify</goal>
+                        </goals>
+                        <configuration>
+                            <systemPropertyVariables>
+                                <native.image.path>${project.build.directory}/${project.build.finalName}-runner</native.image.path>
+                                <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
+                            </systemPropertyVariables>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/ConceptResource.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/ConceptResource.java
new file mode 100644
index 0000000000..2df069e953
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/ConceptResource.java
@@ -0,0 +1,274 @@
+package com.bakdata.conquery.quarkus.api;
+
+import java.util.*;
+
+import com.bakdata.conquery.quarkus.ids.ConceptId;
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.quarkus.services.DatasetService;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.smallrye.common.constraint.Nullable;
+import jakarta.inject.Inject;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+import org.eclipse.microprofile.openapi.annotations.Operation;
+
+@Path("/api/concepts")
+@Produces(MediaType.APPLICATION_JSON)
+public class ConceptResource {
+
+	@Inject
+	DatasetService datasetService;
+
+	@GET
+	@Path("/{conceptId}")
+	@Operation(
+			summary = "Get concept details",
+			description = "Returns a concept map keyed by concept id, compatible with frontend tree loading."
+	)
+	public Map<String, ConceptNodeResponse> getConcept(@PathParam("conceptId") @NotBlank String conceptId) {
+
+		DatasetCatalogRepository.Concept concept = datasetService.requireConcept(conceptId);
+		ConceptId parsedConceptId = ConceptId.parse(conceptId);
+
+		Map<String, ConceptNodeResponse> nodes = new HashMap<>();
+
+		Map<ConceptId, DatasetCatalogRepository.ConceptElement> children = concept.children();
+
+		// TODO Populate matching statistics and their derived date ranges once imported event statistics are available.
+		ConceptNodeResponse node = new ConceptNodeResponse(concept.label(), concept.description(), null, null, concept.childrenIds().stream().map(ConceptId::toString).toList(), 0L, 0L, null, false, concept.additionalInfos(), excludeFromTimeAggregation(concept), concept.connectors().stream().map(this::toConnectorResponse).toList(), concept.selects().stream().map(this::toSelectResponse).toList());
+		nodes.put(parsedConceptId.toString(), node);
+
+		// Add children
+		children.forEach((id, child) -> {
+			ConceptNodeResponse childNode = new ConceptNodeResponse(child.label(), child.description(), null, child.parentId().toString(), child.children().stream().map(ConceptId::toString).toList(), 0L, 0L, null, false, child.additionalInfos(), null, List.of(), List.of());
+			nodes.put(id.toString(), childNode);
+		});
+
+		return nodes;
+	}
+
+	private boolean excludeFromTimeAggregation(DatasetCatalogRepository.Concept concept) {
+		return concept.defaultExcludeFromTimeAggregation()
+				|| concept.connectors().stream().allMatch(connector -> connector.validityDates().isEmpty());
+	}
+
+	private ConnectorResponse toConnectorResponse(DatasetCatalogRepository.Connector connector) {
+		DatasetCatalogRepository.TableRecord tableRecord = datasetService.requireTable(connector.tableId());
+		List<String> supportedSecondaryIds = tableRecord.columns().stream()
+				.map(DatasetCatalogRepository.ColumnRecord::secondaryId)
+				.filter(Objects::nonNull)
+				.distinct()
+				.toList();
+		return new ConnectorResponse(
+				connector.tableId().toString(),
+				connector.id().toString(),
+				connector.label(),
+				connector.isDefault(),
+				connector.filters().stream().map(this::toFilterResponse).toList(),
+				connector.selects().stream().map(this::toSelectResponse).toList(),
+				toDateColumnResponse(connector),
+				supportedSecondaryIds
+		);
+	}
+
+	private DateColumnResponse toDateColumnResponse(DatasetCatalogRepository.Connector connector) {
+		if (connector.validityDates().isEmpty()) {
+			return null;
+		}
+		List<ValueResponse> options = connector.validityDates().stream()
+				.map(validityDate -> new ValueResponse(validityDate.id().toString(), validityDate.label()))
+				.toList();
+		return new DateColumnResponse(options, options.getFirst().value(), null, connector.validityDatesDescription());
+	}
+
+	private SelectResponse toSelectResponse(DatasetCatalogRepository.Select select) {
+		return new SelectResponse(
+				select.id().toString(),
+				select.label(),
+				select.description(),
+				select.defaultSelected(),
+				toSelectResultTypeResponse(select.resultType())
+		);
+	}
+
+	private SelectResponse toSelectResponse(DatasetCatalogRepository.ConceptSelect select) {
+		return new SelectResponse(
+				select.id().toString(),
+				select.label(),
+				select.description(),
+				select.defaultSelected(),
+				toSelectResultTypeResponse(select.resultType())
+		);
+	}
+
+	private SelectResultTypeResponse toSelectResultTypeResponse(DatasetCatalogRepository.SelectResultType resultType) {
+		return new SelectResultTypeResponse(
+				resultType.type(),
+				resultType.elementType() == null ? null : new ElementTypeResponse(resultType.elementType().type())
+		);
+	}
+
+	private FilterResponse toFilterResponse(DatasetCatalogRepository.Filter filter) {
+		return new FilterResponse(
+				filter.id().toString(),
+				filter.label(),
+				filter.type(),
+				filter.unit(),
+				filter.tooltip(),
+				filter.options().stream()
+						.map(option -> new FrontendValue(option.value(), option.label(), option.optionValue()))
+						.toList(),
+				filter.min(),
+				filter.max(),
+				filter.pattern(),
+				filter.allowDropFile(),
+				filter.creatable(),
+				filter.defaultValue()
+		);
+	}
+
+
+	@POST
+	@Path("/{conceptId}/resolve")
+	@Operation(summary = "Resolve concept codes", description = "Resolves uploaded concept codes to concept ids for the same dataset as the requested root concept.")
+	public ConceptResolveResponse resolveConceptCodes(@PathParam("conceptId") @NotBlank String conceptId, @Valid @NotNull ConceptCodeList payload) {
+		DatasetService.ConceptCodeResolution resolution = datasetService.resolveConceptCodes(conceptId, payload.concepts);
+		return new ConceptResolveResponse(resolution.resolvedConcepts(), resolution.unknownCodes());
+	}
+
+	public record ConceptNodeResponse(
+			String label,
+			String description,
+			Boolean active,
+			String parent,
+			List<String> children,
+			Long matchingEntries,
+			Long matchingEntities,
+			Boolean detailsAvailable,
+			Boolean codeListResolvable,
+			List<DatasetCatalogRepository.AdditionalInfo> additionalInfos,
+			Boolean excludeFromTimeAggregation,
+			List<ConnectorResponse> tables,
+			List<SelectResponse> selects
+	) {
+	}
+
+	public record ConnectorResponse(
+			String id,
+			String connectorId,
+			String label,
+			@JsonProperty("default") Boolean isDefault,
+			List<FilterResponse> filters,
+			List<SelectResponse> selects,
+			DateColumnResponse dateColumn,
+			List<String> supportedSecondaryIds
+	) {
+	}
+
+	public record ColumnResponse(
+			String id,
+			String label,
+			ColumnType type,
+			String secondaryId
+	) {
+	}
+
+	public record SelectResponse(
+			String id,
+			String label,
+			String description,
+			@JsonProperty("default") Boolean defaultSelected,
+			SelectResultTypeResponse resultType
+	) {
+	}
+
+	public record SelectResultTypeResponse(
+			String type,
+			ElementTypeResponse elementType
+	) {
+	}
+
+	public record ElementTypeResponse(String type) {
+	}
+
+	public record FilterResponse(
+
+			@NotNull String id,
+			/**
+			 * User readable name of the Filter.
+			 */
+			@NotEmpty String label,
+			/**
+			 * Kind of filter: Communicates to the frontend which UI element to use and what values are valid.
+			 */
+			@NotEmpty String type,
+			/**
+			 * Used as display unit for enumerations etc in UI elements.
+			 */
+			String unit,
+
+			/**
+			 * Displayed on hover for filters.
+			 */
+			String tooltip,
+
+			List<FrontendValue> options,
+
+			/**
+			 * min value for range filters.
+			 */
+			Integer min,
+			/**
+			 * max value for range filters.
+			 */
+			Integer max,
+
+			String pattern,
+			/**
+			 * If true, enables users to use drag and drop files into the filter element (usually for {@link com.bakdata.conquery.models.datasets.concepts.filters.specific.SelectFilter}).
+			 */
+			boolean allowDropFile,
+			/**
+			 * If true, user can manually insert their input. At the moment only true for SelectFilter without any enabled backing searches.
+			 */
+			boolean creatable,
+			/**
+			 * If set, default value used for the filter by the frontend.
+			 */
+			@Nullable Object defaultValue
+	) {
+	}
+
+	record FrontendValue(String value, String label, String optionValue) {
+	}
+
+	public record DateColumnResponse(List<ValueResponse> options, String defaultValue, String value, String tooltip) {
+	}
+
+	public record ValueResponse(String value, String label) {
+	}
+
+	public record ConceptResolveResponse(List<String> resolvedConcepts, List<String> unknownCodes) {
+	}
+
+	public static final class ConceptCodeList {
+		public final @NotNull
+		@NotEmpty List<@NotBlank String> concepts;
+
+		@JsonCreator
+		public ConceptCodeList(@JsonProperty("concepts") List<String> concepts) {
+			this.concepts = concepts;
+		}
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/ConceptsResponse.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/ConceptsResponse.java
new file mode 100644
index 0000000000..0e7dd5565b
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/ConceptsResponse.java
@@ -0,0 +1,40 @@
+package com.bakdata.conquery.quarkus.api;
+
+import java.util.List;
+import java.util.Map;
+
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+public record ConceptsResponse(
+		List<SecondaryIdResponse> secondaryIds,
+		Map<String, ConceptSummaryResponse> concepts
+) {
+	public record SecondaryIdResponse(
+			String id,
+			String label,
+			String description
+	) {
+	}
+
+	public record ConceptSummaryResponse(
+			String label,
+			String description,
+			@Schema(description = "Whether this node can be dragged/selected in the query editor. "
+								  + "When detailsAvailable is false (folder/structure node), this should be false.")
+			Boolean active,
+			String parent,
+			List<String> children,
+			Long matchingEntries,
+			Long matchingEntities,
+			@Schema(description = "Whether detailed concept contents are available via /api/concepts/{conceptId}. "
+								  + "If false, this node is a folder/structure node and should not be draggable.")
+			Boolean detailsAvailable,
+			Boolean codeListResolvable,
+			List<DatasetCatalogRepository.AdditionalInfo> additionalInfos,
+			Boolean excludeFromTimeAggregation,
+			List<ConceptResource.ConnectorResponse> tables,
+			List<ConceptResource.SelectResponse> selects
+	) {
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/DatasetFormConfigResource.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/DatasetFormConfigResource.java
new file mode 100644
index 0000000000..d590155e15
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/DatasetFormConfigResource.java
@@ -0,0 +1,100 @@
+package com.bakdata.conquery.quarkus.api;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.bakdata.conquery.quarkus.services.DatasetService;
+import com.bakdata.conquery.quarkus.services.FormConfigService;
+import io.quarkus.security.identity.SecurityIdentity;
+import jakarta.enterprise.inject.Instance;
+import jakarta.inject.Inject;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.core.MediaType;
+import org.eclipse.microprofile.openapi.annotations.Operation;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Path("/api/datasets")
+@Produces(MediaType.APPLICATION_JSON)
+public class DatasetFormConfigResource {
+
+	@Inject
+    DatasetService datasetService;
+
+	@Inject
+    FormConfigService formConfigService;
+
+	@Inject
+	Instance<SecurityIdentity> identity;
+
+	@POST
+	@Path("/{datasetId}/form-configs")
+	@Operation(
+			summary = "Create a form configuration",
+			description = "Creates a form configuration for the dataset and returns its id."
+	)
+	public PostFormConfigResponse postConfig(
+			@PathParam("datasetId") String datasetId,
+			@Valid @NotNull FormConfigCreatePayload payload
+	) {
+		datasetService.requireDataset(datasetId);
+		return formConfigService.create(datasetId, payload, SecurityIdentityUtil.resolveUserName(identity));
+	}
+
+	@GET
+	@Path("/{datasetId}/form-configs")
+	@Operation(
+			summary = "List form configurations",
+			description = "Returns form configuration metadata for the dataset."
+	)
+	public List<FormConfigOverviewResponse> getConfigs(
+			@PathParam("datasetId") String datasetId,
+			@QueryParam("formType") Set<String> formType
+	) {
+		datasetService.requireDataset(datasetId);
+		return formConfigService.list(datasetId, formType, SecurityIdentityUtil.resolveUserName(identity));
+	}
+
+	public static final class FormConfigCreatePayload {
+		@NotBlank
+		public String formType;
+
+		public String label;
+
+		@NotNull
+		public List<@NotBlank String> tags = List.of();
+
+		@NotNull
+		@Schema(
+				description = "Opaque form values payload saved by the frontend.",
+				implementation = Object.class
+		)
+		public Map<String, Object> values;
+	}
+
+	public record PostFormConfigResponse(
+			String id
+	) {
+	}
+
+	public record FormConfigOverviewResponse(
+			String id,
+			String formType,
+			String label,
+			List<String> tags,
+			String ownerName,
+			String createdAt,
+			boolean own,
+			boolean shared,
+			boolean system
+	) {
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/DatasetsResource.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/DatasetsResource.java
new file mode 100644
index 0000000000..560affa4a6
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/DatasetsResource.java
@@ -0,0 +1,433 @@
+package com.bakdata.conquery.quarkus.api;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UncheckedIOException;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Stream;
+
+import com.bakdata.conquery.quarkus.config.EntityPreviewRuntimeConfig;
+import com.bakdata.conquery.quarkus.config.FormQueriesRuntimeConfig;
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValue;
+import com.bakdata.conquery.quarkus.ids.ConceptId;
+import com.bakdata.conquery.quarkus.ids.StructureNodeId;
+import com.bakdata.conquery.quarkus.services.DatasetService;
+import com.bakdata.conquery.quarkus.services.EntityQueryService;
+import com.bakdata.conquery.quarkus.services.QueryStateService;
+import com.bakdata.conquery.quarkus.services.QueryUploadService;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.quarkus.security.identity.SecurityIdentity;
+import jakarta.enterprise.inject.Instance;
+import jakarta.inject.Inject;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+import org.eclipse.microprofile.openapi.annotations.Operation;
+
+@Path("/api/datasets")
+@Produces(MediaType.APPLICATION_JSON)
+public class DatasetsResource {
+	@Inject
+	DatasetService datasetService;
+
+	@Inject
+	EntityPreviewRuntimeConfig entityPreviewConfig;
+
+	@Inject
+	FormQueriesRuntimeConfig formQueriesConfig;
+
+	@Inject
+	ObjectMapper objectMapper;
+
+	@Inject
+	QueryStateService queryStateService;
+
+	@Inject
+	QueryUploadService queryUploadService;
+
+	@Inject
+	EntityQueryService entityQueryService;
+
+	@Inject
+	Instance<SecurityIdentity> identity;
+
+	@GET
+	public List<DatasetResponse> getDatasets() {
+		return datasetService.listDatasets().stream()
+							 .map(entry -> new DatasetResponse(entry.id().toString(), entry.label()))
+							 .toList();
+	}
+
+	@GET
+	@Path("/{datasetId}/entity-preview")
+	public EntityPreviewResponse getEntityPreview(@PathParam("datasetId") String datasetId) {
+		datasetService.requireDataset(datasetId);
+
+		List<EntityPreviewResponse.LabeledSource> allSources =
+				entityPreviewConfig.allSources().stream().map(source -> new EntityPreviewResponse.LabeledSource(source.name(), source.label())).toList();
+
+		List<EntityPreviewResponse.LabeledSource> defaultSources =
+				entityPreviewConfig.defaultSources().stream().map(source -> new EntityPreviewResponse.LabeledSource(source.name(), source.label())).toList();
+
+		List<String> searchFilters = entityPreviewConfig.searchFilters()
+											.map(value -> Stream.of(value.split(","))
+																.map(String::trim)
+																.filter(filter -> !filter.isEmpty())
+																.toList())
+											.orElse(List.of());
+		String searchConcept = entityPreviewConfig.searchConcept().orElse(null);
+
+		return new EntityPreviewResponse(allSources, defaultSources, searchFilters, searchConcept);
+	}
+
+	@GET
+	@Path("/{datasetId}/concepts")
+	@Operation(
+			summary = "Get root concepts for a dataset",
+			description = "Returns top-level concept nodes. Nodes with detailsAvailable=false represent folder/structure nodes."
+	)
+	public ConceptsResponse getConcepts(@PathParam("datasetId") String datasetId) {
+
+		java.util.Map<String, ConceptsResponse.ConceptSummaryResponse> concepts = new LinkedHashMap<>();
+		List<DatasetCatalogRepository.StructureNode> structureNodes = datasetService.listStructureNodesForDataset(datasetId);
+		Map<StructureNodeId, DatasetCatalogRepository.StructureNode> structureNodesById = structureNodes.stream()
+				.collect(java.util.stream.Collectors.toMap(DatasetCatalogRepository.StructureNode::id, node -> node));
+		Map<ConceptId, StructureNodeId> structureParentByConcept = new LinkedHashMap<>();
+		structureNodes.forEach(node -> node.containedRoots().forEach(conceptId -> structureParentByConcept.put(conceptId, node.id())));
+		// TODO Add concept search after the metadata tree and its indexing requirements have been migrated.
+		datasetService.listRootConceptsForDataset(datasetId).forEach(entry -> concepts.put(
+				entry.id().toString(),
+				new ConceptsResponse.ConceptSummaryResponse(
+						entry.label(),
+						entry.description(),
+						true,
+						Optional.ofNullable(structureParentByConcept.get(entry.id())).map(StructureNodeId::toString).orElse(null),
+						entry.childrenIds().stream().map(ConceptId::toString).toList(),
+						0L,
+						0L,
+						true,
+						!entry.children().isEmpty(),
+						entry.additionalInfos(),
+						excludeFromTimeAggregation(entry),
+						// TODO Remove detailed connector filters/selects from this summary once the frontend loads them via /api/concepts/{conceptId}.
+						entry.connectors().stream().map(this::toTableResponse).toList(),
+						entry.selects().stream().map(this::toSelectResponse).toList()
+				)
+		));
+
+		Set<StructureNodeId> visibleStructureNodes = structureNodes.stream()
+				.filter(node -> isVisibleStructureNode(node, structureNodesById))
+				.map(DatasetCatalogRepository.StructureNode::id)
+				.collect(java.util.stream.Collectors.toSet());
+		structureNodes.stream()
+				.sorted(java.util.Comparator.comparingInt(DatasetCatalogRepository.StructureNode::sourceOrder))
+				.filter(node -> visibleStructureNodes.contains(node.id()))
+				.forEach(node -> concepts.put(node.id().toString(), toStructureNodeResponse(node, visibleStructureNodes)));
+
+		return new ConceptsResponse(
+				List.of(),
+				concepts
+		);
+	}
+
+	private boolean excludeFromTimeAggregation(DatasetCatalogRepository.Concept concept) {
+		return concept.defaultExcludeFromTimeAggregation()
+				|| concept.connectors().stream().allMatch(connector -> connector.validityDates().isEmpty());
+	}
+
+	private boolean isVisibleStructureNode(
+			DatasetCatalogRepository.StructureNode node,
+			Map<StructureNodeId, DatasetCatalogRepository.StructureNode> nodesById
+	) {
+		return !node.containedRoots().isEmpty() || node.children().stream()
+				.map(nodesById::get)
+				.filter(Objects::nonNull)
+				.anyMatch(child -> isVisibleStructureNode(child, nodesById));
+	}
+
+	private ConceptsResponse.ConceptSummaryResponse toStructureNodeResponse(
+			DatasetCatalogRepository.StructureNode node,
+			Set<StructureNodeId> visibleStructureNodes
+	) {
+		List<String> children = Stream.concat(
+				node.children().stream().filter(visibleStructureNodes::contains).map(StructureNodeId::toString),
+				node.containedRoots().stream().map(ConceptId::toString)
+		).toList();
+		return new ConceptsResponse.ConceptSummaryResponse(
+				node.label(),
+				node.description(),
+				false,
+				node.parentId() == null ? null : node.parentId().toString(),
+				children,
+				0L,
+				0L,
+				false,
+				false,
+				List.of(),
+				null,
+				null,
+				null
+		);
+	}
+
+
+	private ConceptResource.ConnectorResponse toTableResponse(DatasetCatalogRepository.Connector connector) {
+		// TODO combine this with ConceptResource#toConnectorResponse
+		DatasetCatalogRepository.TableRecord tableRecord = datasetService.requireTable(connector.tableId());
+		List<String> supportedSecondaryIds = tableRecord.columns().stream()
+				.map(DatasetCatalogRepository.ColumnRecord::secondaryId)
+				.filter(Objects::nonNull)
+				.distinct()
+				.toList();
+
+		return new ConceptResource.ConnectorResponse(
+				connector.tableId().toString(),
+				connector.id().toString(),
+				connector.label(),
+				connector.isDefault(),
+				connector.filters().stream().map(this::toFilterResponse).toList(),
+				connector.selects().stream().map(this::toSelectResponse).toList(),
+				toDateColumnResponse(connector),
+				supportedSecondaryIds
+		);
+	}
+
+	private ConceptResource.DateColumnResponse toDateColumnResponse(DatasetCatalogRepository.Connector connector) {
+		if (connector.validityDates().isEmpty()) {
+			return null;
+		}
+		List<ConceptResource.ValueResponse> options = connector.validityDates().stream()
+				.map(validityDate -> new ConceptResource.ValueResponse(validityDate.id().toString(), validityDate.label()))
+				.toList();
+		return new ConceptResource.DateColumnResponse(options, options.getFirst().value(), null, connector.validityDatesDescription());
+	}
+
+	private ConceptResource.SelectResponse toSelectResponse(DatasetCatalogRepository.Select select) {
+		return new ConceptResource.SelectResponse(
+				select.id().toString(),
+				select.label(),
+				select.description(),
+				select.defaultSelected(),
+				toSelectResultTypeResponse(select.resultType())
+		);
+	}
+
+	private ConceptResource.SelectResponse toSelectResponse(DatasetCatalogRepository.ConceptSelect select) {
+		return new ConceptResource.SelectResponse(
+				select.id().toString(),
+				select.label(),
+				select.description(),
+				select.defaultSelected(),
+				toSelectResultTypeResponse(select.resultType())
+		);
+	}
+
+	private ConceptResource.SelectResultTypeResponse toSelectResultTypeResponse(DatasetCatalogRepository.SelectResultType resultType) {
+		return new ConceptResource.SelectResultTypeResponse(
+				resultType.type(),
+				resultType.elementType() == null ? null : new ConceptResource.ElementTypeResponse(resultType.elementType().type())
+		);
+	}
+
+	private ConceptResource.FilterResponse toFilterResponse(DatasetCatalogRepository.Filter filter) {
+		return new ConceptResource.FilterResponse(
+				filter.id().toString(),
+				filter.label(),
+				filter.type(),
+				filter.unit(),
+				filter.tooltip(),
+				filter.options().stream()
+						.map(option -> new ConceptResource.FrontendValue(option.value(), option.label(), option.optionValue()))
+						.toList(),
+				filter.min(),
+				filter.max(),
+				filter.pattern(),
+				filter.allowDropFile(),
+				filter.creatable(),
+				filter.defaultValue()
+				);
+	}
+
+	private ConceptResource.ColumnResponse toColumnResponse(DatasetCatalogRepository.ColumnRecord column) {
+		return new ConceptResource.ColumnResponse(
+				column.id().toString(),
+				column.label(),
+				column.type(),
+				column.secondaryId()
+		);
+	}
+
+
+	@GET
+	@Path("/{datasetId}/form-queries")
+	@Operation(
+			summary = "Get form configurations for a dataset",
+			description = "Returns raw frontend form configuration objects."
+	)
+	public List<Object> getFormQueries(@PathParam("datasetId") String datasetId) {
+		datasetService.requireDataset(datasetId);
+		return formQueriesConfig.resources().stream().map(this::loadFormResource).toList();
+	}
+
+	@GET
+	@Path("/{datasetId}/queries")
+	@Operation(
+			summary = "List queries for a dataset",
+			description = "Returns the query history list for the given dataset."
+	)
+	public List<QuerySummaryResponse> getQueries(@PathParam("datasetId") String datasetId) {
+		datasetService.requireDataset(datasetId);
+		return queryStateService.getDatasetQueries(datasetId);
+	}
+
+	@POST
+	@Path("/{datasetId}/queries")
+	@Operation(
+			summary = "Create a query for a dataset",
+			description = "Accepts a query payload and returns the created query id."
+	)
+	public StartQueryResponse postQueries(@PathParam("datasetId") String datasetId, @Valid @NotNull QuerySubmissionPayload payload) {
+		datasetService.requireDataset(datasetId);
+		return queryStateService.createQuery(datasetId, payload, SecurityIdentityUtil.resolveUserName(identity));
+	}
+
+	@POST
+	@Path("/{datasetId}/queries/upload")
+	@Operation(
+			summary = "Upload query entities",
+			description = "Uploads entity id rows for query upload workflow."
+	)
+	public UploadQueryResponse uploadQueries(
+			@PathParam("datasetId") String datasetId,
+			@Valid @NotNull QueryUploadPayload payload
+	) {
+		datasetService.requireDataset(datasetId);
+		QueryUploadService.UploadResult result = queryUploadService.processUpload(
+				new QueryUploadService.QueryUploadPayload(payload.format, payload.values, payload.label)
+		);
+		return new UploadQueryResponse(result.resolved(), result.unresolvedId(), result.unreadableDate());
+	}
+
+	@POST
+	@Path("/{datasetId}/queries/entity")
+	@Operation(
+			summary = "Get entity history",
+			description = "Not implemented yet in the Quarkus backend."
+	)
+	public EntityQueryService.EntityHistoryResponse getEntityHistory(
+			@PathParam("datasetId") String datasetId,
+			@Valid @NotNull EntityHistoryRequest payload
+	) {
+		datasetService.requireDataset(datasetId);
+		return entityQueryService.getEntityHistory(
+				new EntityQueryService.EntityHistoryRequest(
+						payload.idKind,
+						payload.entityId,
+						payload.time,
+						payload.sources
+				)
+		);
+	}
+
+	@POST
+	@Path("/{datasetId}/queries/resolve-entities")
+	@Operation(
+			summary = "Resolve entities from filter values",
+			description = "Not implemented yet in the Quarkus backend."
+	)
+	public List<Map<String, String>> resolveEntities(
+			@PathParam("datasetId") String datasetId,
+			@Valid @NotNull List<@Valid FilterValue> payload
+	) {
+		datasetService.requireDataset(datasetId);
+		return entityQueryService.resolveEntities(payload);
+	}
+
+	private Object loadFormResource(String path) {
+		ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+		try (InputStream input = classLoader.getResourceAsStream(path)) {
+			if (input == null) {
+				throw new IllegalStateException("Configured form resource does not exist: " + path);
+			}
+			return objectMapper.readValue(input, Object.class);
+		}
+		catch (IOException e) {
+			throw new UncheckedIOException("Failed to parse form resource: " + path, e);
+		}
+	}
+
+	public record QuerySummaryResponse(
+			String id,
+			String label,
+			Long numberOfResults,
+			String createdAt,
+			List<String> tags,
+			boolean own,
+			String ownerName,
+			boolean system,
+			List<QueryResource.ResultUrlResponse> resultUrls,
+			boolean shared,
+			boolean canExpand,
+			String queryType,
+			String secondaryId,
+			boolean containsDates
+	) {
+	}
+
+	public record StartQueryResponse(
+			String id
+	) {
+	}
+
+	public record UploadQueryResponse(
+			int resolved,
+			List<List<String>> unresolvedId,
+			List<List<String>> unreadableDate
+	) {
+	}
+
+	public static final class QueryUploadPayload {
+		public final @NotNull @NotEmpty List<@NotBlank String> format;
+		public final @NotNull List<@NotNull List<@NotBlank String>> values;
+		public final @NotBlank String label;
+
+		public QueryUploadPayload(List<String> format, List<List<String>> values, String label) {
+			this.format = format;
+			this.values = values;
+			this.label = label;
+		}
+	}
+
+	public static final class EntityHistoryRequest {
+		public final @NotBlank String idKind;
+		public final @NotBlank String entityId;
+		public final @NotNull @Valid QuerySubmissionPayload.DateRangePayload time;
+		public final @NotNull @NotEmpty List<@NotBlank String> sources;
+
+		public EntityHistoryRequest(String idKind, String entityId, QuerySubmissionPayload.DateRangePayload time, List<String> sources) {
+			this.idKind = idKind;
+			this.entityId = entityId;
+			this.time = time;
+			this.sources = sources;
+		}
+	}
+
+	public record DatasetResponse(
+			String id,
+			String label
+	) {
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/EntityPreviewResponse.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/EntityPreviewResponse.java
new file mode 100644
index 0000000000..dd3386da05
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/EntityPreviewResponse.java
@@ -0,0 +1,19 @@
+package com.bakdata.conquery.quarkus.api;
+
+import java.util.List;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+public record EntityPreviewResponse(
+		List<LabeledSource> all,
+		@JsonProperty("default")
+		List<LabeledSource> defaultSources,
+		List<String> searchFilters,
+		String searchConcept
+) {
+	public record LabeledSource(
+			String name,
+			String label
+	) {
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/FilterResource.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/FilterResource.java
new file mode 100644
index 0000000000..03c2f3cd7a
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/FilterResource.java
@@ -0,0 +1,128 @@
+package com.bakdata.conquery.quarkus.api;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.OptionalInt;
+
+import jakarta.inject.Inject;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+import org.eclipse.microprofile.openapi.annotations.Operation;
+
+@Path("/api/filters")
+@Produces(MediaType.APPLICATION_JSON)
+public class FilterResource {
+
+	@Inject
+	FilterService filterService;
+
+	@POST
+	@Path("/{filterId}/resolve")
+	@Operation(
+			summary = "Resolve uploaded filter values",
+			description = "Resolves a list of raw values for a given filter id."
+	)
+	public FilterResolveResponse resolve(
+			@PathParam("filterId") @NotBlank String filterId,
+			@Valid @NotNull FilterValues payload
+	) {
+		FilterService.FilterResolveResult result = filterService.resolveFilterValues(filterId, payload.values);
+		return new FilterResolveResponse(
+				new ResolvedFilterResponse(
+						result.resolvedFilter().tableId(),
+						result.resolvedFilter().filterId(),
+						result.resolvedFilter().value().stream()
+							  .map(value -> new ResolvedFilterValueResponse(value.label(), value.value(), value.optionValue()))
+							  .toList()
+				),
+				result.unknownCodes()
+		);
+	}
+
+	@POST
+	@Path("/{filterId}/autocomplete")
+	@Operation(
+			summary = "Autocomplete filter values",
+			description = "Returns autocomplete suggestions for a filter."
+	)
+	public AutocompleteResponse autocomplete(
+			@PathParam("filterId") @NotBlank String filterId,
+			@Valid @NotNull AutocompleteRequest payload
+	) {
+		FilterService.FilterAutocompleteResult result = filterService.autocomplete(filterId, payload.text, payload.page, payload.pageSize);
+		return new AutocompleteResponse(
+				result.total(),
+				result.values().stream()
+					  .map(value -> new AutocompleteValueResponse(
+							  value.label(),
+							  value.value(),
+							  value.optionValue(),
+							  value.templateValues(),
+							  value.disabled()
+					  ))
+					  .toList()
+		);
+	}
+
+	public static final class FilterValues {
+		public final @NotNull @NotEmpty List<@NotBlank String> values;
+
+		public FilterValues(List<String> values) {
+			this.values = values;
+		}
+	}
+
+	public static final class AutocompleteRequest {
+		public final @NotNull Optional<String> text;
+		public final @NotNull OptionalInt page;
+		public final @NotNull OptionalInt pageSize;
+
+		public AutocompleteRequest(Optional<String> text, OptionalInt page, OptionalInt pageSize) {
+			this.text = text;
+			this.page = page;
+			this.pageSize = pageSize;
+		}
+	}
+
+	public record FilterResolveResponse(
+			ResolvedFilterResponse resolvedFilter,
+			List<String> unknownCodes
+	) {
+	}
+
+	public record ResolvedFilterResponse(
+			String tableId,
+			String filterId,
+			List<ResolvedFilterValueResponse> value
+	) {
+	}
+
+	public record ResolvedFilterValueResponse(
+			String label,
+			String value,
+			String optionValue
+	) {
+	}
+
+	public record AutocompleteResponse(
+			long total,
+			List<AutocompleteValueResponse> values
+	) {
+	}
+
+	public record AutocompleteValueResponse(
+			String label,
+			String value,
+			String optionValue,
+			java.util.Map<String, String> templateValues,
+			boolean disabled
+	) {
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/FilterService.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/FilterService.java
new file mode 100644
index 0000000000..2d77f1cd59
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/FilterService.java
@@ -0,0 +1,99 @@
+package com.bakdata.conquery.quarkus.api;
+
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.OptionalInt;
+
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.ws.rs.BadRequestException;
+
+@ApplicationScoped
+public class FilterService {
+
+	public FilterResolveResult resolveFilterValues(String filterId, List<String> values) {
+		String tableId = extractTableId(filterId);
+		List<ResolvedFilterValue> resolved = values.stream()
+											 .map(String::trim)
+											 .filter(value -> !value.isEmpty())
+											 .distinct()
+											 .map(value -> new ResolvedFilterValue(value, value, value))
+											 .toList();
+
+		return new FilterResolveResult(
+				new ResolvedFilter(tableId, filterId, resolved),
+				List.of()
+		);
+	}
+
+	public FilterAutocompleteResult autocomplete(String filterId, Optional<String> text, OptionalInt page, OptionalInt pageSize) {
+		int resolvedPage = page.orElse(0);
+		int resolvedPageSize = pageSize.orElse(50);
+		if (resolvedPage < 0) {
+			throw new BadRequestException("page must be >= 0");
+		}
+		if (resolvedPageSize < 1) {
+			throw new BadRequestException("pageSize must be >= 1");
+		}
+
+		String prefix = text.map(String::trim).orElse("");
+		List<String> candidates = List.of(prefix, prefix + "1", prefix + "2", prefix + "3")
+								   .stream()
+								   .map(String::trim)
+								   .filter(value -> !value.isEmpty())
+								   .collect(java.util.stream.Collectors.collectingAndThen(
+										   java.util.stream.Collectors.toCollection(LinkedHashSet::new),
+										   List::copyOf
+								   ));
+
+		int fromIndex = Math.min(resolvedPage * resolvedPageSize, candidates.size());
+		int toIndex = Math.min(fromIndex + resolvedPageSize, candidates.size());
+		List<AutocompleteValue> values = candidates.subList(fromIndex, toIndex)
+										  .stream()
+										  .map(value -> new AutocompleteValue(value, value, value, Map.of(), false))
+										  .toList();
+
+		return new FilterAutocompleteResult(values, candidates.size());
+	}
+
+	private String extractTableId(String filterId) {
+		int separatorIndex = filterId.indexOf(':');
+		return separatorIndex > 0 ? filterId.substring(0, separatorIndex) : filterId;
+	}
+
+	public record FilterResolveResult(
+			ResolvedFilter resolvedFilter,
+			List<String> unknownCodes
+	) {
+	}
+
+	public record ResolvedFilter(
+			String tableId,
+			String filterId,
+			List<ResolvedFilterValue> value
+	) {
+	}
+
+	public record ResolvedFilterValue(
+			String label,
+			String value,
+			String optionValue
+	) {
+	}
+
+	public record FilterAutocompleteResult(
+			List<AutocompleteValue> values,
+			long total
+	) {
+	}
+
+	public record AutocompleteValue(
+			String label,
+			String value,
+			String optionValue,
+			Map<String, String> templateValues,
+			boolean disabled
+	) {
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/FormConfigResource.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/FormConfigResource.java
new file mode 100644
index 0000000000..cf405b20b4
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/FormConfigResource.java
@@ -0,0 +1,95 @@
+package com.bakdata.conquery.quarkus.api;
+
+import java.util.List;
+import java.util.Map;
+
+import com.bakdata.conquery.quarkus.services.FormConfigService;
+import io.quarkus.security.identity.SecurityIdentity;
+import jakarta.enterprise.inject.Instance;
+import jakarta.inject.Inject;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.ws.rs.DELETE;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.PATCH;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+import org.eclipse.microprofile.openapi.annotations.Operation;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Path("/api/form-configs")
+@Produces(MediaType.APPLICATION_JSON)
+public class FormConfigResource {
+
+	@Inject
+    FormConfigService formConfigService;
+
+	@Inject
+	Instance<SecurityIdentity> identity;
+
+	@GET
+	@Path("/{formConfigId}")
+	@Operation(
+			summary = "Get a form configuration",
+			description = "Returns full form configuration metadata and values."
+	)
+	public FormConfigFullResponse getConfig(@PathParam("formConfigId") String formConfigId) {
+		return formConfigService.get(formConfigId, SecurityIdentityUtil.resolveUserName(identity));
+	}
+
+	@PATCH
+	@Path("/{formConfigId}")
+	@Operation(
+			summary = "Patch a form configuration",
+			description = "Patches mutable form configuration fields."
+	)
+	public FormConfigFullResponse patchConfig(
+			@PathParam("formConfigId") String formConfigId,
+			@Valid FormConfigPatchPayload payload
+	) {
+		return formConfigService.patch(formConfigId, payload, SecurityIdentityUtil.resolveUserName(identity));
+	}
+
+	@DELETE
+	@Path("/{formConfigId}")
+	@Operation(
+			summary = "Delete a form configuration",
+			description = "Deletes a stored form configuration."
+	)
+	public void deleteConfig(@PathParam("formConfigId") String formConfigId) {
+		formConfigService.delete(formConfigId);
+	}
+
+	public static final class FormConfigPatchPayload {
+		public String label;
+		public List<@NotBlank String> tags;
+		public List<@NotBlank String> groups;
+
+		@Schema(
+				description = "Opaque form values payload saved by the frontend.",
+				implementation = Object.class
+		)
+		public Map<String, Object> values;
+	}
+
+	public record FormConfigFullResponse(
+			String id,
+			String formType,
+			String label,
+			List<String> tags,
+			String ownerName,
+			String createdAt,
+			boolean own,
+			boolean shared,
+			boolean system,
+			List<String> groups,
+			@Schema(
+					description = "Opaque form values payload saved by the frontend.",
+					implementation = Object.class
+			)
+			Map<String, Object> values
+	) {
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/MeResource.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/MeResource.java
new file mode 100644
index 0000000000..a313571534
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/MeResource.java
@@ -0,0 +1,52 @@
+package com.bakdata.conquery.quarkus.api;
+
+import java.util.List;
+import java.util.Map;
+
+import io.quarkus.security.identity.SecurityIdentity;
+import jakarta.enterprise.inject.Instance;
+import jakarta.inject.Inject;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+
+@Path("/api/me")
+@Produces(MediaType.APPLICATION_JSON)
+public class MeResource {
+	@Inject
+	Instance<SecurityIdentity> identity;
+
+	@GET
+	public MeResponse me() {
+		String userName = SecurityIdentityUtil.resolveUserName(identity);
+
+		return new MeResponse(
+				userName,
+				true,
+				Map.of("imdb", new PermissionFlags(true, true, true)),
+				List.of()
+		);
+	}
+
+	public record MeResponse(
+			String userName,
+			boolean hideLogoutButton,
+			Map<String, PermissionFlags> datasetAbilities,
+			List<GroupInfo> groups
+	) {
+	}
+
+	public record PermissionFlags(
+			boolean canUpload,
+			boolean canViewEntityPreview,
+			boolean canViewQueryPreview
+	) {
+	}
+
+	public record GroupInfo(
+			String id,
+			String label
+	) {
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/PingResource.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/PingResource.java
new file mode 100644
index 0000000000..1ae1d9b6c3
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/PingResource.java
@@ -0,0 +1,23 @@
+package com.bakdata.conquery.quarkus.api;
+
+import java.time.OffsetDateTime;
+import java.util.Map;
+
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+
+@Path("/api/ping")
+@Produces(MediaType.APPLICATION_JSON)
+public class PingResource {
+
+	@GET
+	public Map<String, Object> ping() {
+		return Map.of(
+				"service", "conquery-backend-quarkus",
+				"status", "ok",
+				"timestamp", OffsetDateTime.now().toString()
+		);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/QueryResource.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/QueryResource.java
new file mode 100644
index 0000000000..0f4e173512
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/QueryResource.java
@@ -0,0 +1,346 @@
+package com.bakdata.conquery.quarkus.api;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.services.QueryStateService;
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import jakarta.inject.Inject;
+import jakarta.ws.rs.DELETE;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.PATCH;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+import org.eclipse.microprofile.openapi.annotations.Operation;
+import org.eclipse.microprofile.openapi.annotations.media.DiscriminatorMapping;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Path("/api/queries")
+@Produces(MediaType.APPLICATION_JSON)
+public class QueryResource {
+	@Inject
+    QueryStateService queryStateService;
+
+	@GET
+	@Path("/{queryId}")
+	@Operation(
+			summary = "Get a query by id",
+			description = "Returns the current query execution status and metadata."
+	)
+	public QueryResponse getQuery(@PathParam("queryId") String queryId) {
+		return queryStateService.getQuery(queryId);
+	}
+
+	@POST
+	@Path("/{queryId}/cancel")
+	@Operation(
+			summary = "Cancel a query",
+			description = "Cancels a running query."
+	)
+	public void cancelQuery(@PathParam("queryId") String queryId) {
+		queryStateService.cancelQuery(queryId);
+	}
+
+	@PATCH
+	@Path("/{queryId}")
+	@Operation(
+			summary = "Patch query metadata",
+			description = "Updates mutable query metadata like label, tags, sharing and groups."
+	)
+	public void patchQuery(@PathParam("queryId") String queryId, QueryPatchPayload payload) {
+		queryStateService.patchQuery(
+				queryId,
+				new QueryStateService.QueryPatch(payload.label, payload.tags, payload.shared, payload.groups)
+		);
+	}
+
+	@DELETE
+	@Path("/{queryId}")
+	@Operation(
+			summary = "Delete a query",
+			description = "Deletes a query from history."
+	)
+	public void deleteQuery(@PathParam("queryId") String queryId) {
+		queryStateService.deleteQuery(queryId);
+	}
+
+	@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY, property = "status", visible = true)
+	@JsonSubTypes({
+			@JsonSubTypes.Type(value = NewQueryResponse.class, name = "NEW"),
+			@JsonSubTypes.Type(value = RunningQueryResponse.class, name = "RUNNING"),
+			@JsonSubTypes.Type(value = DoneQueryResponse.class, name = "DONE"),
+			@JsonSubTypes.Type(value = FailedQueryResponse.class, name = "FAILED"),
+			@JsonSubTypes.Type(value = CanceledQueryResponse.class, name = "CANCELED")
+	})
+	@Schema(
+			description = "Query response with status-based polymorphism.",
+			discriminatorProperty = "status",
+			oneOf = {
+					NewQueryResponse.class,
+					RunningQueryResponse.class,
+					DoneQueryResponse.class,
+					FailedQueryResponse.class,
+					CanceledQueryResponse.class
+			},
+			discriminatorMapping = {
+					@DiscriminatorMapping(value = "NEW", schema = NewQueryResponse.class),
+					@DiscriminatorMapping(value = "RUNNING", schema = RunningQueryResponse.class),
+					@DiscriminatorMapping(value = "DONE", schema = DoneQueryResponse.class),
+					@DiscriminatorMapping(value = "FAILED", schema = FailedQueryResponse.class),
+					@DiscriminatorMapping(value = "CANCELED", schema = CanceledQueryResponse.class)
+			}
+	)
+	public interface QueryResponse {
+	}
+
+	public abstract static class BaseQueryResponse implements QueryResponse {
+		public final String id;
+		public final String label;
+		public final String createdAt;
+		public final boolean own;
+		public final boolean shared;
+		public final boolean system;
+		public final List<String> tags;
+		public final QueryDefinition query;
+		public final String secondaryId;
+		public final String ownerName;
+		public final List<String> groups;
+		public final boolean canExpand;
+		public final List<String> availableSecondaryIds;
+		public final QueryStatus status;
+
+		protected BaseQueryResponse(
+				String id,
+				String label,
+				String createdAt,
+				boolean own,
+				boolean shared,
+				boolean system,
+				List<String> tags,
+				QueryDefinition query,
+				String secondaryId,
+				String ownerName,
+				List<String> groups,
+				boolean canExpand,
+				List<String> availableSecondaryIds,
+				QueryStatus status
+		) {
+			this.id = id;
+			this.label = label;
+			this.createdAt = createdAt;
+			this.own = own;
+			this.shared = shared;
+			this.system = system;
+			this.tags = tags;
+			this.query = query;
+			this.secondaryId = secondaryId;
+			this.ownerName = ownerName;
+			this.groups = groups;
+			this.canExpand = canExpand;
+			this.availableSecondaryIds = availableSecondaryIds;
+			this.status = status;
+		}
+	}
+
+	public static final class NewQueryResponse extends BaseQueryResponse {
+		public NewQueryResponse(
+				String id,
+				String label,
+				String createdAt,
+				boolean own,
+				boolean shared,
+				boolean system,
+				List<String> tags,
+				QueryDefinition query,
+				String secondaryId,
+				String ownerName,
+				List<String> groups,
+				boolean canExpand,
+				List<String> availableSecondaryIds
+		) {
+			super(id, label, createdAt, own, shared, system, tags, query, secondaryId, ownerName, groups, canExpand, availableSecondaryIds, QueryStatus.NEW);
+		}
+	}
+
+	public static final class RunningQueryResponse extends BaseQueryResponse {
+		public final Double progress;
+
+		public RunningQueryResponse(
+				String id,
+				String label,
+				String createdAt,
+				boolean own,
+				boolean shared,
+				boolean system,
+				List<String> tags,
+				QueryDefinition query,
+				String secondaryId,
+				String ownerName,
+				List<String> groups,
+				boolean canExpand,
+				List<String> availableSecondaryIds,
+				Double progress
+		) {
+			super(id, label, createdAt, own, shared, system, tags, query, secondaryId, ownerName, groups, canExpand, availableSecondaryIds, QueryStatus.RUNNING);
+			this.progress = progress;
+		}
+	}
+
+	public static final class DoneQueryResponse extends BaseQueryResponse {
+		public final Long numberOfResults;
+		public final List<ResultUrlResponse> resultUrls;
+		public final QueryType queryType;
+		public final long requiredTime;
+		public final boolean containsDates;
+
+		public DoneQueryResponse(
+				String id,
+				String label,
+				String createdAt,
+				boolean own,
+				boolean shared,
+				boolean system,
+				List<String> tags,
+				QueryDefinition query,
+				String secondaryId,
+				String ownerName,
+				List<String> groups,
+				boolean canExpand,
+				List<String> availableSecondaryIds,
+				Long numberOfResults,
+				List<ResultUrlResponse> resultUrls,
+				QueryType queryType,
+				long requiredTime,
+				boolean containsDates
+		) {
+			super(id, label, createdAt, own, shared, system, tags, query, secondaryId, ownerName, groups, canExpand, availableSecondaryIds, QueryStatus.DONE);
+			this.numberOfResults = numberOfResults;
+			this.resultUrls = resultUrls;
+			this.queryType = queryType;
+			this.requiredTime = requiredTime;
+			this.containsDates = containsDates;
+		}
+	}
+
+	public static final class FailedQueryResponse extends BaseQueryResponse {
+		public final ErrorResponse error;
+
+		public FailedQueryResponse(
+				String id,
+				String label,
+				String createdAt,
+				boolean own,
+				boolean shared,
+				boolean system,
+				List<String> tags,
+				QueryDefinition query,
+				String secondaryId,
+				String ownerName,
+				List<String> groups,
+				boolean canExpand,
+				List<String> availableSecondaryIds,
+				ErrorResponse error
+		) {
+			super(id, label, createdAt, own, shared, system, tags, query, secondaryId, ownerName, groups, canExpand, availableSecondaryIds, QueryStatus.FAILED);
+			this.error = error;
+		}
+	}
+
+	public static final class CanceledQueryResponse extends BaseQueryResponse {
+		public final ErrorResponse error;
+
+		public CanceledQueryResponse(
+				String id,
+				String label,
+				String createdAt,
+				boolean own,
+				boolean shared,
+				boolean system,
+				List<String> tags,
+				QueryDefinition query,
+				String secondaryId,
+				String ownerName,
+				List<String> groups,
+				boolean canExpand,
+				List<String> availableSecondaryIds,
+				ErrorResponse error
+		) {
+			super(id, label, createdAt, own, shared, system, tags, query, secondaryId, ownerName, groups, canExpand, availableSecondaryIds, QueryStatus.CANCELED);
+			this.error = error;
+		}
+	}
+
+	public enum QueryStatus {
+		NEW,
+		RUNNING,
+		DONE,
+		FAILED,
+		CANCELED
+	}
+
+	public enum QueryType {
+		CONCEPT_QUERY,
+		SECONDARY_ID_QUERY
+	}
+
+	@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY, property = "type", visible = true)
+	@JsonSubTypes({
+			@JsonSubTypes.Type(value = ConceptQueryDefinition.class, name = "CONCEPT_QUERY"),
+			@JsonSubTypes.Type(value = SecondaryIdQueryDefinition.class, name = "SECONDARY_ID_QUERY")
+	})
+	@Schema(
+			description = "Submitted query definition, discriminated by `type`.",
+			discriminatorProperty = "type",
+			oneOf = {ConceptQueryDefinition.class, SecondaryIdQueryDefinition.class},
+			discriminatorMapping = {
+					@DiscriminatorMapping(value = "CONCEPT_QUERY", schema = ConceptQueryDefinition.class),
+					@DiscriminatorMapping(value = "SECONDARY_ID_QUERY", schema = SecondaryIdQueryDefinition.class)
+			}
+	)
+	public abstract static class QueryDefinition {
+		public final QueryType type;
+		public final QuerySubmissionPayload.QueryNode root;
+
+		protected QueryDefinition(QueryType type, QuerySubmissionPayload.QueryNode root) {
+			this.type = type;
+			this.root = root;
+		}
+	}
+
+	public static final class ConceptQueryDefinition extends QueryDefinition {
+		public ConceptQueryDefinition(QuerySubmissionPayload.QueryNode root) {
+			super(QueryType.CONCEPT_QUERY, root);
+		}
+	}
+
+	public static final class SecondaryIdQueryDefinition extends QueryDefinition {
+		public final String secondaryId;
+
+		public SecondaryIdQueryDefinition(QuerySubmissionPayload.QueryNode root, String secondaryId) {
+			super(QueryType.SECONDARY_ID_QUERY, root);
+			this.secondaryId = secondaryId;
+		}
+	}
+
+	public record ErrorResponse(
+			String message,
+			String code
+	) {
+	}
+
+	public record ResultUrlResponse(
+			String label,
+			String url
+	) {
+	}
+
+	public static final class QueryPatchPayload {
+		public String label;
+		public List<String> tags;
+		public Boolean shared;
+		public List<String> groups;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/QuerySubmissionPayload.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/QuerySubmissionPayload.java
new file mode 100644
index 0000000000..bedb995c53
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/QuerySubmissionPayload.java
@@ -0,0 +1,252 @@
+package com.bakdata.conquery.quarkus.api;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Map;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValue;
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import jakarta.validation.Valid;
+import org.eclipse.microprofile.openapi.annotations.media.DiscriminatorMapping;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@JsonTypeInfo(
+		use = JsonTypeInfo.Id.NAME,
+		include = JsonTypeInfo.As.EXISTING_PROPERTY,
+		property = "type",
+		visible = true,
+		defaultImpl = QuerySubmissionPayload.GenericQuerySubmissionPayload.class
+)
+@JsonSubTypes({
+		@JsonSubTypes.Type(value = QuerySubmissionPayload.ConceptQuerySubmissionPayload.class, name = "CONCEPT_QUERY"),
+		@JsonSubTypes.Type(value = QuerySubmissionPayload.SecondaryIdQuerySubmissionPayload.class, name = "SECONDARY_ID_QUERY"),
+		@JsonSubTypes.Type(value = QuerySubmissionPayload.GenericQuerySubmissionPayload.class, name = "FORM_QUERY")
+})
+@Schema(
+		description = "Query submission payload, discriminated by `type`.",
+		discriminatorProperty = "type",
+		oneOf = {
+				QuerySubmissionPayload.ConceptQuerySubmissionPayload.class,
+				QuerySubmissionPayload.SecondaryIdQuerySubmissionPayload.class,
+				QuerySubmissionPayload.GenericQuerySubmissionPayload.class
+		},
+		discriminatorMapping = {
+				@DiscriminatorMapping(value = "CONCEPT_QUERY", schema = QuerySubmissionPayload.ConceptQuerySubmissionPayload.class),
+				@DiscriminatorMapping(value = "SECONDARY_ID_QUERY", schema = QuerySubmissionPayload.SecondaryIdQuerySubmissionPayload.class),
+				@DiscriminatorMapping(value = "FORM_QUERY", schema = QuerySubmissionPayload.GenericQuerySubmissionPayload.class)
+		}
+)
+public abstract class QuerySubmissionPayload {
+	public String type;
+
+	public static final class ConceptQuerySubmissionPayload extends QuerySubmissionPayload {
+		@Schema(description = "Query root node. Polymorphic and discriminated by field `type`.")
+		@Valid
+		public QueryNode root;
+
+		public ConceptQuerySubmissionPayload() {
+			this.type = "CONCEPT_QUERY";
+		}
+	}
+
+	public static final class SecondaryIdQuerySubmissionPayload extends QuerySubmissionPayload {
+		public String secondaryId;
+		@Schema(description = "Query root node. Polymorphic and discriminated by field `type`.")
+		@Valid
+		public QueryNode root;
+
+		public SecondaryIdQuerySubmissionPayload() {
+			this.type = "SECONDARY_ID_QUERY";
+		}
+	}
+
+	public static final class GenericQuerySubmissionPayload extends QuerySubmissionPayload {
+		public Map<String, Object> values;
+
+		public GenericQuerySubmissionPayload() {
+		}
+	}
+
+	@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type")
+	@JsonSubTypes({
+			@JsonSubTypes.Type(value = AndNode.class, name = "AND"),
+			@JsonSubTypes.Type(value = OrNode.class, name = "OR"),
+			@JsonSubTypes.Type(value = NegationNode.class, name = "NEGATION"),
+			@JsonSubTypes.Type(value = DateRestrictionNode.class, name = "DATE_RESTRICTION"),
+			@JsonSubTypes.Type(value = ConceptNode.class, name = "CONCEPT"),
+			@JsonSubTypes.Type(value = SavedQueryNode.class, name = "SAVED_QUERY"),
+			@JsonSubTypes.Type(value = TemporalNode.class, name = "TEMPORAL"),
+			@JsonSubTypes.Type(value = ExternalResolvedNode.class, name = "EXTERNAL_RESOLVED")
+	})
+	@Schema(
+			description = "Base query node. Concrete schema is selected via discriminator `type`.",
+			discriminatorProperty = "type",
+			oneOf = {
+					AndNode.class,
+					OrNode.class,
+					NegationNode.class,
+					DateRestrictionNode.class,
+					ConceptNode.class,
+					SavedQueryNode.class,
+					TemporalNode.class,
+					ExternalResolvedNode.class
+			},
+			discriminatorMapping = {
+					@DiscriminatorMapping(value = "AND", schema = AndNode.class),
+					@DiscriminatorMapping(value = "OR", schema = OrNode.class),
+					@DiscriminatorMapping(value = "NEGATION", schema = NegationNode.class),
+					@DiscriminatorMapping(value = "DATE_RESTRICTION", schema = DateRestrictionNode.class),
+					@DiscriminatorMapping(value = "CONCEPT", schema = ConceptNode.class),
+					@DiscriminatorMapping(value = "SAVED_QUERY", schema = SavedQueryNode.class),
+					@DiscriminatorMapping(value = "TEMPORAL", schema = TemporalNode.class),
+					@DiscriminatorMapping(value = "EXTERNAL_RESOLVED", schema = ExternalResolvedNode.class)
+			}
+	)
+	public abstract static class QueryNode {
+	}
+
+	@Schema(name = "AndQueryNode")
+	public static class AndNode extends QueryNode {
+		public List<@Valid QueryNode> children;
+	}
+
+	@Schema(name = "OrQueryNode")
+	public static class OrNode extends QueryNode {
+		public List<@Valid QueryNode> children;
+	}
+
+	@Schema(name = "NegationQueryNode")
+	public static class NegationNode extends QueryNode {
+		@Valid
+		public QueryNode child;
+	}
+
+	@Schema(name = "DateRestrictionQueryNode")
+	public static class DateRestrictionNode extends QueryNode {
+		@Valid
+		public DateRangePayload dateRange;
+		@Valid
+		public QueryNode child;
+	}
+
+	@Schema(name = "ConceptQueryNode")
+	public static class ConceptNode extends QueryNode {
+		public List<String> ids;
+		public String label;
+		public Boolean excludeFromTimeAggregation;
+		public Boolean excludeFromSecondaryId;
+		public List<@Valid TableConfigPayload> tables;
+		public List<String> selects;
+	}
+
+	@Schema(name = "SavedQueryNode")
+	public static class SavedQueryNode extends QueryNode {
+		public String query;
+	}
+
+	@Schema(name = "TemporalQueryNode")
+	public static class TemporalNode extends QueryNode {
+		public TemporalModePayload mode;
+		public QueryNode index;
+		public String indexSelector;
+		public QueryNode compare;
+		public String compareSelector;
+	}
+
+	@Schema(name = "ExternalResolvedQueryNode")
+	public static class ExternalResolvedNode extends QueryNode {
+	}
+
+	@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY, property = "type", visible = true)
+	@JsonSubTypes({
+			@JsonSubTypes.Type(value = BeforeTemporalModePayload.class, name = "BEFORE"),
+			@JsonSubTypes.Type(value = AfterTemporalModePayload.class, name = "AFTER"),
+			@JsonSubTypes.Type(value = WhileTemporalModePayload.class, name = "WHILE")
+	})
+	@Schema(
+			description = "Temporal mode, discriminated by `type`.",
+			discriminatorProperty = "type",
+			oneOf = {
+					BeforeTemporalModePayload.class,
+					AfterTemporalModePayload.class,
+					WhileTemporalModePayload.class
+			},
+			discriminatorMapping = {
+					@DiscriminatorMapping(value = "BEFORE", schema = BeforeTemporalModePayload.class),
+					@DiscriminatorMapping(value = "AFTER", schema = AfterTemporalModePayload.class),
+					@DiscriminatorMapping(value = "WHILE", schema = WhileTemporalModePayload.class)
+			}
+	)
+	public abstract static class TemporalModePayload {
+		public TemporalModeType type;
+
+		protected TemporalModePayload() {
+		}
+
+		protected TemporalModePayload(TemporalModeType type) {
+			this.type = type;
+		}
+	}
+
+	public static final class BeforeTemporalModePayload extends TemporalModePayload {
+		public DayRangePayload days;
+
+		public BeforeTemporalModePayload() {
+			super(TemporalModeType.BEFORE);
+		}
+
+		public BeforeTemporalModePayload(DayRangePayload days) {
+			this();
+			this.days = days;
+		}
+	}
+
+	public static final class AfterTemporalModePayload extends TemporalModePayload {
+		public DayRangePayload days;
+
+		public AfterTemporalModePayload() {
+			super(TemporalModeType.AFTER);
+		}
+
+		public AfterTemporalModePayload(DayRangePayload days) {
+			this();
+			this.days = days;
+		}
+	}
+
+	public static final class WhileTemporalModePayload extends TemporalModePayload {
+		public WhileTemporalModePayload() {
+			super(TemporalModeType.WHILE);
+		}
+	}
+
+	public enum TemporalModeType {
+		BEFORE,
+		AFTER,
+		WHILE
+	}
+
+	public static class DayRangePayload {
+		public Integer min;
+		public Integer max;
+	}
+
+	public static class DateRangePayload {
+		public LocalDate min;
+		public LocalDate max;
+	}
+
+	public static class TableConfigPayload {
+		public String id;
+		@Valid
+		public DateColumnConfigPayload dateColumn;
+		public List<String> selects;
+		public List<@Valid FilterValue> filters;
+	}
+
+	public static class DateColumnConfigPayload {
+		public String value;
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/SecurityIdentityUtil.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/SecurityIdentityUtil.java
new file mode 100644
index 0000000000..ebe35c9429
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/api/SecurityIdentityUtil.java
@@ -0,0 +1,24 @@
+package com.bakdata.conquery.quarkus.api;
+
+import io.quarkus.security.identity.SecurityIdentity;
+import jakarta.enterprise.inject.Instance;
+
+public final class SecurityIdentityUtil {
+
+	private SecurityIdentityUtil() {
+	}
+
+	public static String resolveUserName(Instance<SecurityIdentity> identityInstance) {
+		if (identityInstance.isResolvable()) {
+			SecurityIdentity identity = identityInstance.get();
+			if (identity != null && !identity.isAnonymous() && identity.getPrincipal() != null) {
+				String principalName = identity.getPrincipal().getName();
+				if (principalName != null && !principalName.isBlank()) {
+					return principalName;
+				}
+			}
+		}
+
+		return "anonymous";
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/ConceptCondition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/ConceptCondition.java
new file mode 100644
index 0000000000..7cc4342b02
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/ConceptCondition.java
@@ -0,0 +1,22 @@
+package com.bakdata.conquery.quarkus.concepts.conditions;
+
+import com.bakdata.conquery.quarkus.models.PolymorphicModelBase;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@JsonTypeInfo(
+		use = JsonTypeInfo.Id.NAME,
+		include = JsonTypeInfo.As.EXISTING_PROPERTY,
+		property = "type",
+		visible = true,
+		defaultImpl = UnknownConceptCondition.class
+)
+@Schema(name = "MetadataConceptCondition", description = "Condition assigned to a concept-tree node. The concrete model is selected by `type`.", discriminatorProperty = "type")
+@PolymorphicModelBase(
+		schemaName = "MetadataConceptCondition",
+		description = "Condition assigned to a concept-tree node. The concrete model is selected by `type`."
+)
+public interface ConceptCondition {
+
+	String getType();
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/ConceptConditionProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/ConceptConditionProvider.java
new file mode 100644
index 0000000000..29343669d6
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/ConceptConditionProvider.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.quarkus.concepts.conditions;
+
+import com.bakdata.conquery.quarkus.models.PolymorphicModelTypeProvider;
+
+public interface ConceptConditionProvider<T extends ConceptCondition> extends PolymorphicModelTypeProvider<ConceptCondition, T> {
+
+	default String type() {
+		return typeId();
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/UnknownConceptCondition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/UnknownConceptCondition.java
new file mode 100644
index 0000000000..5bf2a256fc
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/UnknownConceptCondition.java
@@ -0,0 +1,38 @@
+package com.bakdata.conquery.quarkus.concepts.conditions;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter;
+import com.fasterxml.jackson.annotation.JsonAnySetter;
+import jakarta.validation.constraints.AssertTrue;
+
+public final class UnknownConceptCondition implements ConceptCondition {
+
+	private String type;
+	private final Map<String, Object> properties = new LinkedHashMap<>();
+
+	@Override
+	public String getType() {
+		return type;
+	}
+
+	public void setType(String type) {
+		this.type = type;
+	}
+
+	@JsonAnySetter
+	public void put(String name, Object value) {
+		properties.put(name, value);
+	}
+
+	@JsonAnyGetter
+	public Map<String, Object> properties() {
+		return Map.copyOf(properties);
+	}
+
+	@AssertTrue(message = "must use a registered concept condition type")
+	public boolean isRegisteredType() {
+		return false;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/AbstractConceptCondition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/AbstractConceptCondition.java
new file mode 100644
index 0000000000..9cf0553226
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/AbstractConceptCondition.java
@@ -0,0 +1,16 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.ConceptCondition;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@JsonIgnoreProperties(ignoreUnknown = true)
+public abstract class AbstractConceptCondition implements ConceptCondition {
+
+	@Schema(description = "Concept-condition implementation discriminator.")
+	private String type;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/AndConceptCondition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/AndConceptCondition.java
new file mode 100644
index 0000000000..599744315e
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/AndConceptCondition.java
@@ -0,0 +1,22 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.definitions;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.ConceptCondition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotEmpty;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataAndConceptCondition", description = "Matches when all nested conditions match.")
+@PolymorphicModelSubtype(base = ConceptCondition.class, id = "AND")
+public final class AndConceptCondition extends AbstractConceptCondition {
+
+	@Valid
+	@NotEmpty
+	private List<ConceptCondition> conditions;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/ColumnEqualConceptCondition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/ColumnEqualConceptCondition.java
new file mode 100644
index 0000000000..3c95aab596
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/ColumnEqualConceptCondition.java
@@ -0,0 +1,24 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.definitions;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.ConceptCondition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotEmpty;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataColumnEqualConceptCondition", description = "Matches when another column of a record/event has one of the configured values.")
+@PolymorphicModelSubtype(base = ConceptCondition.class, id = "COLUMN_EQUAL")
+public final class ColumnEqualConceptCondition extends AbstractConceptCondition {
+
+	@NotEmpty
+	private List<String> values;
+
+	@NotBlank
+	private String column;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/EqualConceptCondition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/EqualConceptCondition.java
new file mode 100644
index 0000000000..8bc6702a83
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/EqualConceptCondition.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.definitions;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.ConceptCondition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotEmpty;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataEqualConceptCondition", description = "Matches when a value is contained exactly in this list.")
+@PolymorphicModelSubtype(base = ConceptCondition.class, id = "EQUAL")
+public final class EqualConceptCondition extends AbstractConceptCondition {
+
+	@NotEmpty
+	private List<String> values;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/NotConceptCondition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/NotConceptCondition.java
new file mode 100644
index 0000000000..d096e3aa35
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/NotConceptCondition.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.ConceptCondition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataNotConceptCondition", description = "Matches when its nested condition does not match.")
+@PolymorphicModelSubtype(base = ConceptCondition.class, id = "NOT")
+public final class NotConceptCondition extends AbstractConceptCondition {
+
+	@Valid
+	@NotNull
+	private ConceptCondition condition;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/OrConceptCondition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/OrConceptCondition.java
new file mode 100644
index 0000000000..975003c66c
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/OrConceptCondition.java
@@ -0,0 +1,22 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.definitions;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.ConceptCondition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotEmpty;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataOrConceptCondition", description = "Matches when at least one nested condition matches.")
+@PolymorphicModelSubtype(base = ConceptCondition.class, id = "OR")
+public final class OrConceptCondition extends AbstractConceptCondition {
+
+	@Valid
+	@NotEmpty
+	private List<ConceptCondition> conditions;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/PrefixListConceptCondition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/PrefixListConceptCondition.java
new file mode 100644
index 0000000000..9a100c7080
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/PrefixListConceptCondition.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.definitions;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.ConceptCondition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotEmpty;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataPrefixListConceptCondition", description = "Matches values beginning with one of the configured prefixes.")
+@PolymorphicModelSubtype(base = ConceptCondition.class, id = "PREFIX_LIST")
+public final class PrefixListConceptCondition extends AbstractConceptCondition {
+
+	@NotEmpty
+	private List<String> prefixes;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/PrefixRangeConceptCondition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/PrefixRangeConceptCondition.java
new file mode 100644
index 0000000000..147303a2b9
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/PrefixRangeConceptCondition.java
@@ -0,0 +1,27 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.ConceptCondition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.AssertTrue;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataPrefixRangeConceptCondition", description = "Matches fixed-length prefixes inside an inclusive lexical range.")
+@PolymorphicModelSubtype(base = ConceptCondition.class, id = "PREFIX_RANGE")
+public final class PrefixRangeConceptCondition extends AbstractConceptCondition {
+
+	@NotBlank
+	private String min;
+
+	@NotBlank
+	private String max;
+
+	@AssertTrue(message = "min and max must have equal lengths and min must be smaller than or equal to max")
+	public boolean isValidRange() {
+		return min == null || max == null || min.length() == max.length() && min.compareTo(max) <= 0;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/PresentConceptCondition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/PresentConceptCondition.java
new file mode 100644
index 0000000000..99fdeb06d2
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/definitions/PresentConceptCondition.java
@@ -0,0 +1,18 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.ConceptCondition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataPresentConceptCondition", description = "Matches when the configured column in the same record/event has a value present.")
+@PolymorphicModelSubtype(base = ConceptCondition.class, id = "PRESENT")
+public final class PresentConceptCondition extends AbstractConceptCondition {
+
+	@NotBlank
+	private String column;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/AbstractConceptConditionProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/AbstractConceptConditionProvider.java
new file mode 100644
index 0000000000..a5bb96d458
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/AbstractConceptConditionProvider.java
@@ -0,0 +1,18 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.providers;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.ConceptCondition;
+import com.bakdata.conquery.quarkus.concepts.conditions.ConceptConditionProvider;
+
+abstract class AbstractConceptConditionProvider<T extends ConceptCondition> implements ConceptConditionProvider<T> {
+
+	private final Class<T> modelType;
+
+	protected AbstractConceptConditionProvider(Class<T> modelType) {
+		this.modelType = modelType;
+	}
+
+	@Override
+	public Class<T> modelType() {
+		return modelType;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/AndConceptConditionProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/AndConceptConditionProvider.java
new file mode 100644
index 0000000000..c9c05ecdfd
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/AndConceptConditionProvider.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.providers;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.AndConceptCondition;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class AndConceptConditionProvider extends AbstractConceptConditionProvider<AndConceptCondition> {
+
+	public AndConceptConditionProvider() {
+		super(AndConceptCondition.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/ColumnEqualConceptConditionProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/ColumnEqualConceptConditionProvider.java
new file mode 100644
index 0000000000..307d424e5e
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/ColumnEqualConceptConditionProvider.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.providers;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.ColumnEqualConceptCondition;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class ColumnEqualConceptConditionProvider extends AbstractConceptConditionProvider<ColumnEqualConceptCondition> {
+
+	public ColumnEqualConceptConditionProvider() {
+		super(ColumnEqualConceptCondition.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/EqualConceptConditionProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/EqualConceptConditionProvider.java
new file mode 100644
index 0000000000..dde4038ca4
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/EqualConceptConditionProvider.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.providers;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.EqualConceptCondition;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class EqualConceptConditionProvider extends AbstractConceptConditionProvider<EqualConceptCondition> {
+
+	public EqualConceptConditionProvider() {
+		super(EqualConceptCondition.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/NotConceptConditionProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/NotConceptConditionProvider.java
new file mode 100644
index 0000000000..5504e93dac
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/NotConceptConditionProvider.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.providers;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.NotConceptCondition;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class NotConceptConditionProvider extends AbstractConceptConditionProvider<NotConceptCondition> {
+
+	public NotConceptConditionProvider() {
+		super(NotConceptCondition.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/OrConceptConditionProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/OrConceptConditionProvider.java
new file mode 100644
index 0000000000..2e02620e3a
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/OrConceptConditionProvider.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.providers;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.OrConceptCondition;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class OrConceptConditionProvider extends AbstractConceptConditionProvider<OrConceptCondition> {
+
+	public OrConceptConditionProvider() {
+		super(OrConceptCondition.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/PrefixListConceptConditionProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/PrefixListConceptConditionProvider.java
new file mode 100644
index 0000000000..3d5835abbd
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/PrefixListConceptConditionProvider.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.providers;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.PrefixListConceptCondition;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class PrefixListConceptConditionProvider extends AbstractConceptConditionProvider<PrefixListConceptCondition> {
+
+	public PrefixListConceptConditionProvider() {
+		super(PrefixListConceptCondition.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/PrefixRangeConceptConditionProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/PrefixRangeConceptConditionProvider.java
new file mode 100644
index 0000000000..c62075e151
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/PrefixRangeConceptConditionProvider.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.providers;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.PrefixRangeConceptCondition;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class PrefixRangeConceptConditionProvider extends AbstractConceptConditionProvider<PrefixRangeConceptCondition> {
+
+	public PrefixRangeConceptConditionProvider() {
+		super(PrefixRangeConceptCondition.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/PresentConceptConditionProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/PresentConceptConditionProvider.java
new file mode 100644
index 0000000000..032a271e08
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/conditions/providers/PresentConceptConditionProvider.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.quarkus.concepts.conditions.providers;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.PresentConceptCondition;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class PresentConceptConditionProvider extends AbstractConceptConditionProvider<PresentConceptCondition> {
+
+	public PresentConceptConditionProvider() {
+		super(PresentConceptCondition.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/BackendFilterConversionContext.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/BackendFilterConversionContext.java
new file mode 100644
index 0000000000..17fb026ffe
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/BackendFilterConversionContext.java
@@ -0,0 +1,52 @@
+package com.bakdata.conquery.quarkus.concepts.filters;
+
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.quarkus.ids.ConnectorId;
+import com.bakdata.conquery.quarkus.ids.IdPartSanitizer;
+import com.bakdata.conquery.quarkus.ids.TableId;
+import com.bakdata.conquery.models.datasets.ColumnDescriptor;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+
+record BackendFilterConversionContext(
+		ConnectorId connectorId,
+		TableId tableId,
+		DatasetCatalogRepository.TableRecord table,
+		FilterFallbackReporter fallbackReporter
+) implements FilterConversionContext {
+
+	@Override
+	public String idPartFromPreferredOrFallback(String preferred, String fallback, String idType, Object fallbackContext) {
+		if (preferred != null && !preferred.isBlank()) {
+			return preferred.trim();
+		}
+		if (fallback == null || fallback.isBlank()) {
+			throw new IllegalArgumentException("Cannot derive " + idType + " for " + fallbackContext + " because preferred and fallback values are blank.");
+		}
+		String fallbackValue = fallback.trim();
+		String sanitized = IdPartSanitizer.sanitize(fallbackValue, idType + " fallback");
+		fallbackReporter.record(idType, fallbackContext, fallbackValue, sanitized);
+		return sanitized;
+	}
+
+	@Override
+	public ColumnDescriptor requireColumn(String columnName) {
+		ColumnId columnId = columnId(columnName);
+		ColumnDescriptor resolvedColumn = table.columns().stream()
+				.filter(column -> column.id().equals(columnId))
+				.map(record -> new ColumnDescriptor(columnName, record.type()))
+				.findFirst()
+				.orElseThrow(() -> new IllegalArgumentException("Unknown filter column '" + columnId + "' in table '" + tableId + "'."));
+		return resolvedColumn;
+	}
+
+	ColumnId columnId(String columnName) {
+		if (columnName == null || columnName.isBlank()) {
+			throw new IllegalArgumentException("Filter column in connector '" + connectorId + "' must not be blank.");
+		}
+		if (columnName.contains(".")) {
+			throw new IllegalArgumentException("Filter column in connector '" + connectorId + "' must be a local column name without dots: " + columnName);
+		}
+		return new ColumnId(tableId, columnName);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/FilterDefinitionAssembler.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/FilterDefinitionAssembler.java
new file mode 100644
index 0000000000..f7c97272fe
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/FilterDefinitionAssembler.java
@@ -0,0 +1,100 @@
+package com.bakdata.conquery.quarkus.concepts.filters;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValueRegistry;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.quarkus.ids.ConnectorId;
+import com.bakdata.conquery.quarkus.ids.FilterId;
+import com.bakdata.conquery.quarkus.ids.TableId;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinitionProvider;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import lombok.extern.slf4j.Slf4j;
+
+@ApplicationScoped
+@Slf4j
+public class FilterDefinitionAssembler {
+
+	@Inject
+	FilterDefinitionRegistry registry;
+
+	@Inject
+	ObjectMapper objectMapper;
+
+	@Inject
+	FilterValueRegistry filterValueRegistry;
+
+	public List<DatasetCatalogRepository.Filter> assemble(
+			ConnectorId connectorId,
+			TableId tableId,
+			DatasetCatalogRepository.TableRecord table,
+			List<FilterDefinition> definitions,
+			FilterFallbackReporter fallbackReporter,
+			boolean strictFilterTypes
+	) {
+		if (definitions == null) {
+			return List.of();
+		}
+
+		BackendFilterConversionContext context = new BackendFilterConversionContext(connectorId, tableId, table, fallbackReporter);
+		List<DatasetCatalogRepository.Filter> filters = new ArrayList<>();
+		for (FilterDefinition definition : definitions) {
+			assemble(context, definition, strictFilterTypes).ifPresent(filters::add);
+		}
+		return List.copyOf(filters);
+	}
+
+	private Optional<DatasetCatalogRepository.Filter> assemble(BackendFilterConversionContext context, FilterDefinition definition, boolean strictFilterTypes) {
+		Optional<FilterDefinitionProvider<?>> provider = registry.find(definition);
+		if (provider.isPresent()) {
+			return Optional.of(convert(context, definition, provider.get()));
+		}
+
+		String type = definition.getType();
+		String reason = type == null || type.isBlank() ? "missing filter type" : "unknown filter type '" + type + "'";
+		String message = "Skipping filter for connector '" + context.connectorId() + "' because of " + reason + ": " + objectMapper.valueToTree(definition);
+		if (strictFilterTypes) {
+			throw new IllegalStateException(message);
+		}
+		log.warn("{}", message);
+		return Optional.empty();
+	}
+
+	private <T extends FilterDefinition> DatasetCatalogRepository.Filter convert(BackendFilterConversionContext context, FilterDefinition definition, FilterDefinitionProvider<T> provider) {
+		T payload = provider.modelType().cast(definition);
+		FilterResult result = provider.convert(context, payload);
+		if (!provider.acceptedValueTypes().contains(result.valueType())) {
+			throw new IllegalStateException("Filter provider " + provider.getClass().getName()
+					+ " produced filter value type '" + result.valueType() + "' but accepts " + provider.acceptedValueTypes());
+		}
+		filterValueRegistry.require(result.valueType());
+		List<ColumnId> requiredColumns = result.requiredColumns().stream()
+				.map(context::requireColumn)
+				.map(column -> context.columnId(column.name()))
+				.toList();
+		return new DatasetCatalogRepository.Filter(
+				new FilterId(context.connectorId(), result.name()),
+				definition,
+				result.label(),
+				result.valueType(),
+				result.unit(),
+				result.tooltip(),
+				result.options().stream()
+						.map(option -> new DatasetCatalogRepository.FrontendValue(option.value(), option.label(), option.optionValue()))
+						.toList(),
+				result.min(),
+				result.max(),
+				result.pattern(),
+				result.allowDropFile(),
+				result.creatable(),
+				result.defaultValue(),
+				requiredColumns
+		);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/FilterDefinitionRegistry.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/FilterDefinitionRegistry.java
new file mode 100644
index 0000000000..fe50fd8910
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/FilterDefinitionRegistry.java
@@ -0,0 +1,45 @@
+package com.bakdata.conquery.quarkus.concepts.filters;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValueRegistry;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinitionProvider;
+import jakarta.annotation.PostConstruct;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.inject.Instance;
+import jakarta.inject.Inject;
+
+@ApplicationScoped
+public class FilterDefinitionRegistry {
+
+	@Inject
+	Instance<FilterDefinitionProvider<?>> providers;
+
+	@Inject
+	FilterValueRegistry filterValueRegistry;
+
+	private Map<Class<? extends FilterDefinition>, FilterDefinitionProvider<?>> providersByModelType = Map.of();
+
+	@PostConstruct
+	void init() {
+		Map<Class<? extends FilterDefinition>, FilterDefinitionProvider<?>> index = new LinkedHashMap<>();
+		for (FilterDefinitionProvider<?> provider : providers) {
+			if (provider.acceptedValueTypes().isEmpty()) {
+				throw new IllegalStateException("Filter provider " + provider.getClass().getName() + " does not declare any accepted filter value types");
+			}
+			provider.acceptedValueTypes().forEach(filterValueRegistry::require);
+			FilterDefinitionProvider<?> previous = index.put(provider.modelType(), provider);
+			if (previous != null) {
+				throw new IllegalStateException("Duplicate filter provider for model type " + provider.modelType().getName() + ": " + previous.getClass().getName() + " and " + provider.getClass().getName());
+			}
+		}
+		providersByModelType = Map.copyOf(index);
+	}
+
+	public Optional<FilterDefinitionProvider<?>> find(FilterDefinition definition) {
+		return Optional.ofNullable(providersByModelType.get(definition.getClass()));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/FilterFallbackReporter.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/FilterFallbackReporter.java
new file mode 100644
index 0000000000..36c7910bbd
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/FilterFallbackReporter.java
@@ -0,0 +1,6 @@
+package com.bakdata.conquery.quarkus.concepts.filters;
+
+@FunctionalInterface
+public interface FilterFallbackReporter {
+	void record(String idType, Object context, String fallbackValue, String sanitized);
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/StaticFrontendValue.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/StaticFrontendValue.java
new file mode 100644
index 0000000000..11792645a9
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/StaticFrontendValue.java
@@ -0,0 +1,8 @@
+package com.bakdata.conquery.quarkus.concepts.filters;
+
+public record StaticFrontendValue(
+		String value,
+		String label,
+		String optionValue
+) {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/BigMultiSelectFilterDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/BigMultiSelectFilterDefinition.java
new file mode 100644
index 0000000000..b150081fd1
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/BigMultiSelectFilterDefinition.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.quarkus.concepts.filters.definitions;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataBigMultiSelectFilter", description = "Selection filter whose values are fetched by the frontend.")
+@PolymorphicModelSubtype(base = FilterDefinition.class, id = "BIG_MULTI_SELECT")
+public final class BigMultiSelectFilterDefinition extends SelectFilterDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/CategoryMaxSumFilterDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/CategoryMaxSumFilterDefinition.java
new file mode 100644
index 0000000000..c50fa28c84
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/CategoryMaxSumFilterDefinition.java
@@ -0,0 +1,25 @@
+package com.bakdata.conquery.quarkus.concepts.filters.definitions;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.AbstractFilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelSubtype;
+import com.fasterxml.jackson.annotation.JsonAlias;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataCategoryMaxSumFilter", description = "Numeric range filter over category-wise maximum sums.")
+// TODO May rename this to DistincMaxSumFilter
+@PolymorphicModelSubtype(base = FilterDefinition.class, id = "CATEGORY_MAX_SUM")
+public final class CategoryMaxSumFilterDefinition extends AbstractFilterDefinition {
+	@Schema(description = "Category column.")
+	@JsonAlias("category")
+	private String categoryColumn;
+	@Schema(description = "Value column.")
+	@JsonAlias("value")
+	private String valueColumn;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/CountFilterDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/CountFilterDefinition.java
new file mode 100644
index 0000000000..c8d33ed8e6
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/CountFilterDefinition.java
@@ -0,0 +1,23 @@
+package com.bakdata.conquery.quarkus.concepts.filters.definitions;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.SingleColumnFilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelSubtype;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataCountFilter", description = "Range filter over an event or distinct-value count.")
+@PolymorphicModelSubtype(base = FilterDefinition.class, id = "COUNT")
+public final class CountFilterDefinition extends SingleColumnFilterDefinition {
+	@Schema(description = "Optional local columns whose value combinations are counted distinctly.")
+	private List<String> distinctByColumn;
+
+	// TODO remove this flag, decide if distinct "implicit" on value of distinctByColumn
+	@Schema(description = "Whether the configured count column itself is counted distinctly.")
+	private boolean distinct;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/CountQuartersFilterDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/CountQuartersFilterDefinition.java
new file mode 100644
index 0000000000..c7a0467f6d
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/CountQuartersFilterDefinition.java
@@ -0,0 +1,11 @@
+package com.bakdata.conquery.quarkus.concepts.filters.definitions;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.SingleColumnFilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataCountQuartersFilter", description = "Range filter over the number of quarters covered by a date range.")
+@PolymorphicModelSubtype(base = FilterDefinition.class, id = "COUNT_QUARTERS")
+public final class CountQuartersFilterDefinition extends SingleColumnFilterDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/DateDistanceFilterDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/DateDistanceFilterDefinition.java
new file mode 100644
index 0000000000..971cef892e
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/DateDistanceFilterDefinition.java
@@ -0,0 +1,17 @@
+package com.bakdata.conquery.quarkus.concepts.filters.definitions;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.SingleColumnFilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelSubtype;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataDateDistanceFilter", description = "Range filter over the distance between a date and the reference date.")
+@PolymorphicModelSubtype(base = FilterDefinition.class, id = "DATE_DISTANCE")
+public final class DateDistanceFilterDefinition extends SingleColumnFilterDefinition {
+	@Schema(description = "Unit used to measure the date distance, for example YEARS or DAYS.", defaultValue = "YEARS")
+	private String timeUnit;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/DurationSumFilterDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/DurationSumFilterDefinition.java
new file mode 100644
index 0000000000..a27dc600cc
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/DurationSumFilterDefinition.java
@@ -0,0 +1,19 @@
+package com.bakdata.conquery.quarkus.concepts.filters.definitions;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.SingleColumnFilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelSubtype;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataDurationSumFilter", description = "Range filter over summed date-range durations.")
+@PolymorphicModelSubtype(base = FilterDefinition.class, id = "DURATION_SUM")
+public final class DurationSumFilterDefinition extends SingleColumnFilterDefinition {
+	@Schema(description = "Local columns used to remove duplicate date ranges before summing durations.")
+	private List<String> distinctBy;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/FlagsFilterDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/FlagsFilterDefinition.java
new file mode 100644
index 0000000000..beb59f2134
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/FlagsFilterDefinition.java
@@ -0,0 +1,21 @@
+package com.bakdata.conquery.quarkus.concepts.filters.definitions;
+
+import java.util.Map;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.AbstractFilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotEmpty;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataFlagsFilter", description = "Multi-selection filter backed by one boolean column per option.")
+@PolymorphicModelSubtype(base = FilterDefinition.class, id = "FLAGS")
+public final class FlagsFilterDefinition extends AbstractFilterDefinition {
+	@NotEmpty
+	@Schema(description = "Mapping from selectable labels to local boolean columns.", required = true)
+	private Map<String, String> flags;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/MultiSelectFilterDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/MultiSelectFilterDefinition.java
new file mode 100644
index 0000000000..e8d957c78c
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/MultiSelectFilterDefinition.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.quarkus.concepts.filters.definitions;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataMultiSelectFilter", description = "Selection filter whose values may be embedded in the concept metadata.")
+@PolymorphicModelSubtype(base = FilterDefinition.class, id = "SELECT")
+public final class MultiSelectFilterDefinition extends SelectFilterDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/NumberFilterDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/NumberFilterDefinition.java
new file mode 100644
index 0000000000..ad327f51ae
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/NumberFilterDefinition.java
@@ -0,0 +1,11 @@
+package com.bakdata.conquery.quarkus.concepts.filters.definitions;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.SingleColumnFilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataNumberFilter", description = "Numeric range filter over one column.")
+@PolymorphicModelSubtype(base = FilterDefinition.class, id = "NUMBER")
+public final class NumberFilterDefinition extends SingleColumnFilterDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/PrefixTextFilterDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/PrefixTextFilterDefinition.java
new file mode 100644
index 0000000000..595af9f9d3
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/PrefixTextFilterDefinition.java
@@ -0,0 +1,11 @@
+package com.bakdata.conquery.quarkus.concepts.filters.definitions;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.SingleColumnFilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataPrefixTextFilter", description = "Text-prefix filter over one string column.")
+@PolymorphicModelSubtype(base = FilterDefinition.class, id = "PREFIX_TEXT")
+public final class PrefixTextFilterDefinition extends SingleColumnFilterDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/QuartersInYearFilterDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/QuartersInYearFilterDefinition.java
new file mode 100644
index 0000000000..f77a987f75
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/QuartersInYearFilterDefinition.java
@@ -0,0 +1,11 @@
+package com.bakdata.conquery.quarkus.concepts.filters.definitions;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.SingleColumnFilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataQuartersInYearFilter", description = "Range filter over the quarter of a date.")
+@PolymorphicModelSubtype(base = FilterDefinition.class, id = "QUARTERS_IN_YEAR")
+public final class QuartersInYearFilterDefinition extends SingleColumnFilterDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/SelectFilterDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/SelectFilterDefinition.java
new file mode 100644
index 0000000000..fa9e675d60
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/SelectFilterDefinition.java
@@ -0,0 +1,21 @@
+package com.bakdata.conquery.quarkus.concepts.filters.definitions;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.SingleColumnFilterDefinition;
+
+import java.util.List;
+import java.util.Map;
+
+import com.bakdata.conquery.quarkus.concepts.filters.StaticFrontendValue;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+public abstract class SelectFilterDefinition extends SingleColumnFilterDefinition {
+
+	@Schema(description = "Inline mapping from stored values to labels displayed by the frontend.")
+	private Map<String, String> labels;
+	@Schema(description = "Inline frontend options. Takes precedence over labels when present.")
+	private List<StaticFrontendValue> options;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/SingleSelectFilterDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/SingleSelectFilterDefinition.java
new file mode 100644
index 0000000000..77461439e1
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/SingleSelectFilterDefinition.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.quarkus.concepts.filters.definitions;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataSingleSelectFilter", description = "Selection filter accepting one value.")
+@PolymorphicModelSubtype(base = FilterDefinition.class, id = "SINGLE_SELECT")
+public final class SingleSelectFilterDefinition extends SelectFilterDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/SumFilterDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/SumFilterDefinition.java
new file mode 100644
index 0000000000..0b63721108
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/definitions/SumFilterDefinition.java
@@ -0,0 +1,21 @@
+package com.bakdata.conquery.quarkus.concepts.filters.definitions;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.SingleColumnFilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelSubtype;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataSumFilter", description = "Numeric range filter over a sum or difference of sums.")
+@PolymorphicModelSubtype(base = FilterDefinition.class, id = "SUM")
+public final class SumFilterDefinition extends SingleColumnFilterDefinition {
+	@Schema(description = "Optional local column subtracted from the primary sum column.")
+	private String subtractColumn;
+	@Schema(description = "Local columns used to remove duplicate values before summing.")
+	private List<String> distinctByColumn;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/AbstractFilterProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/AbstractFilterProvider.java
new file mode 100644
index 0000000000..0dcca5feff
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/AbstractFilterProvider.java
@@ -0,0 +1,159 @@
+package com.bakdata.conquery.quarkus.concepts.filters.providers;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.FlagsFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.SelectFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValue;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.IntegerRangeFilterValue;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.MoneyRangeFilterValue;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.RealRangeFilterValue;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import com.bakdata.conquery.models.datasets.ColumnDescriptor;
+import com.bakdata.conquery.quarkus.plugin.api.filters.AbstractFilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinitionProvider;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import com.bakdata.conquery.quarkus.plugin.api.filters.SingleColumnFilterDefinition;
+
+abstract class AbstractFilterProvider<T extends AbstractFilterDefinition> implements FilterDefinitionProvider<T> {
+
+	private final Class<T> modelType;
+	private final Set<String> acceptedValueTypes;
+
+	@SafeVarargs
+	protected AbstractFilterProvider(Class<T> modelType, Class<? extends FilterValue>... acceptedValueTypes) {
+		this.modelType = modelType;
+		this.acceptedValueTypes = Set.of(acceptedValueTypes).stream()
+				.map(AbstractFilterProvider::valueType)
+				.collect(Collectors.toUnmodifiableSet());
+	}
+
+	@Override
+	public Class<T> modelType() {
+		return modelType;
+	}
+
+	@Override
+	public Set<String> acceptedValueTypes() {
+		return acceptedValueTypes;
+	}
+
+	protected FilterResult filter(
+			FilterConversionContext context,
+			T payload,
+			Class<? extends FilterValue> valueType,
+			Integer min,
+			Integer max,
+			boolean creatable,
+			List<ColumnDescriptor> requiredColumns
+	) {
+		String name = context.idPartFromPreferredOrFallback(payload.getName(), payload.getLabel(), "filter id", type());
+		String label = firstNonBlank(payload.getLabel(), payload.getName()).orElse(name);
+		return new FilterResult(
+				name,
+				label,
+				frontendType(valueType),
+				payload.getUnit(),
+				payload.getTooltip(),
+				options(payload),
+				min == null ? payload.getMin() : min,
+				max == null ? payload.getMax() : max,
+				payload.getPattern(),
+				Boolean.TRUE.equals(payload.getAllowDropFile()),
+				creatable,
+				payload.getDefaultValue(),
+				requiredColumns.stream().map(ColumnDescriptor::name).toList()
+		);
+	}
+
+	protected String frontendType(Class<? extends FilterValue> valueType) {
+		String type = valueType(valueType);
+		if (!acceptedValueTypes.contains(type)) {
+			throw new IllegalArgumentException("Filter provider " + getClass().getName()
+					+ " does not accept filter value type " + type);
+		}
+		return type;
+	}
+
+	protected ColumnDescriptor requiredColumn(FilterConversionContext context, SingleColumnFilterDefinition payload) {
+		String column = firstNonBlank(payload.getColumn())
+				.orElseThrow(() -> new IllegalArgumentException("Filter " + type() + " must define column."));
+		return context.requireColumn(column);
+	}
+
+	protected List<ColumnDescriptor> optionalColumns(FilterConversionContext context, List<String> values) {
+		if (values == null) {
+			return List.of();
+		}
+		return values.stream().map(context::requireColumn).toList();
+	}
+
+	protected List<FilterResult.Option> options(AbstractFilterDefinition payload) {
+		if (payload instanceof SelectFilterDefinition select && select.getOptions() != null) {
+			return select.getOptions().stream()
+					.map(value -> new FilterResult.Option(value.value(), value.label(), value.optionValue()))
+					.toList();
+		}
+		if (payload instanceof SelectFilterDefinition select && select.getLabels() != null) {
+			return select.getLabels().entrySet().stream()
+					.map(entry -> new FilterResult.Option(entry.getKey(), entry.getValue(), entry.getKey()))
+					.toList();
+		}
+		if (payload instanceof FlagsFilterDefinition flags && flags.getFlags() != null) {
+			return flags.getFlags().keySet().stream()
+					.map(value -> new FilterResult.Option(value, value, value))
+					.toList();
+		}
+		return List.of();
+	}
+
+	protected List<ColumnDescriptor> columns(ColumnDescriptor primary, List<ColumnDescriptor> additional) {
+		List<ColumnDescriptor> columns = new ArrayList<>();
+		if (primary != null) {
+			columns.add(primary);
+		}
+		if (additional != null) {
+			columns.addAll(additional);
+		}
+		return columns;
+	}
+
+	protected List<ColumnDescriptor> flagColumns(FilterConversionContext context, Map<String, String> flags) {
+		if (flags == null) {
+			return List.of();
+		}
+		return flags.values().stream().map(context::requireColumn).toList();
+	}
+
+	protected Class<? extends FilterValue> numericRangeValueType(ColumnDescriptor column) {
+		return switch (column.type()) {
+			case MONEY -> MoneyRangeFilterValue.class;
+			case INTEGER -> IntegerRangeFilterValue.class;
+			case DECIMAL, REAL -> RealRangeFilterValue.class;
+			default -> RealRangeFilterValue.class;
+		};
+	}
+
+	private static String valueType(Class<? extends FilterValue> valueType) {
+		PolymorphicModelSubtype subtype = valueType.getAnnotation(PolymorphicModelSubtype.class);
+		if (subtype == null) {
+			throw new IllegalArgumentException("Filter value " + valueType.getName() + " has no @PolymorphicModelSubtype");
+		}
+		return subtype.id();
+	}
+
+	private Optional<String> firstNonBlank(String... values) {
+		for (String value : values) {
+			if (value != null && !value.isBlank()) {
+				return Optional.of(value.trim());
+			}
+		}
+		return Optional.empty();
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/BigMultiSelectFilterProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/BigMultiSelectFilterProvider.java
new file mode 100644
index 0000000000..d28de0b49d
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/BigMultiSelectFilterProvider.java
@@ -0,0 +1,21 @@
+package com.bakdata.conquery.quarkus.concepts.filters.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.BigMultiSelectFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.BigMultiSelectFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class BigMultiSelectFilterProvider extends AbstractFilterProvider<BigMultiSelectFilterDefinition> {
+	public BigMultiSelectFilterProvider() {
+		super(BigMultiSelectFilterDefinition.class, BigMultiSelectFilterValue.class);
+	}
+
+	@Override
+	public FilterResult convert(FilterConversionContext context, BigMultiSelectFilterDefinition payload) {
+		return filter(context, payload, BigMultiSelectFilterValue.class, null, null, true, List.of(requiredColumn(context, payload)));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/CategoryMaxSumFilterProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/CategoryMaxSumFilterProvider.java
new file mode 100644
index 0000000000..5018d2f601
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/CategoryMaxSumFilterProvider.java
@@ -0,0 +1,31 @@
+package com.bakdata.conquery.quarkus.concepts.filters.providers;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.models.datasets.ColumnDescriptor;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.CategoryMaxSumFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.IntegerRangeFilterValue;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.MoneyRangeFilterValue;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.RealRangeFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class CategoryMaxSumFilterProvider extends AbstractFilterProvider<CategoryMaxSumFilterDefinition> {
+
+	public CategoryMaxSumFilterProvider() {
+		super(CategoryMaxSumFilterDefinition.class, IntegerRangeFilterValue.class, MoneyRangeFilterValue.class, RealRangeFilterValue.class);
+	}
+
+
+	@Override
+	public FilterResult convert(FilterConversionContext context, CategoryMaxSumFilterDefinition payload) {
+		List<ColumnDescriptor> required = new ArrayList<>();
+		ColumnDescriptor valueColumn = context.requireColumn(payload.getValueColumn());
+		required.add(valueColumn);
+		required.add(context.requireColumn(payload.getCategoryColumn()));
+		return filter(context, payload, numericRangeValueType(valueColumn), null, null, false, required);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/CountFilterProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/CountFilterProvider.java
new file mode 100644
index 0000000000..e32a8c5e4d
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/CountFilterProvider.java
@@ -0,0 +1,21 @@
+package com.bakdata.conquery.quarkus.concepts.filters.providers;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.models.datasets.ColumnDescriptor;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.CountFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.IntegerRangeFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class CountFilterProvider extends AbstractFilterProvider<CountFilterDefinition> {
+	public CountFilterProvider() {
+		super(CountFilterDefinition.class, IntegerRangeFilterValue.class);
+	}
+
+	@Override
+	public FilterResult convert(FilterConversionContext context, CountFilterDefinition payload) {
+		ColumnDescriptor column = requiredColumn(context, payload);
+		return filter(context, payload, IntegerRangeFilterValue.class, 1, null, false, columns(column, optionalColumns(context, payload.getDistinctByColumn())));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/CountQuartersFilterProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/CountQuartersFilterProvider.java
new file mode 100644
index 0000000000..1b40fb19b7
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/CountQuartersFilterProvider.java
@@ -0,0 +1,21 @@
+package com.bakdata.conquery.quarkus.concepts.filters.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.CountQuartersFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.IntegerRangeFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class CountQuartersFilterProvider extends AbstractFilterProvider<CountQuartersFilterDefinition> {
+	public CountQuartersFilterProvider() {
+		super(CountQuartersFilterDefinition.class, IntegerRangeFilterValue.class);
+	}
+
+	@Override
+	public FilterResult convert(FilterConversionContext context, CountQuartersFilterDefinition payload) {
+		return filter(context, payload, IntegerRangeFilterValue.class, 1, null, false, List.of(requiredColumn(context, payload)));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/DateDistanceFilterProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/DateDistanceFilterProvider.java
new file mode 100644
index 0000000000..27dc16393c
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/DateDistanceFilterProvider.java
@@ -0,0 +1,21 @@
+package com.bakdata.conquery.quarkus.concepts.filters.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.DateDistanceFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.IntegerRangeFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class DateDistanceFilterProvider extends AbstractFilterProvider<DateDistanceFilterDefinition> {
+	public DateDistanceFilterProvider() {
+		super(DateDistanceFilterDefinition.class, IntegerRangeFilterValue.class);
+	}
+
+	@Override
+	public FilterResult convert(FilterConversionContext context, DateDistanceFilterDefinition payload) {
+		return filter(context, payload, IntegerRangeFilterValue.class, null, null, false, List.of(requiredColumn(context, payload)));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/DurationSumFilterProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/DurationSumFilterProvider.java
new file mode 100644
index 0000000000..13793e2a91
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/DurationSumFilterProvider.java
@@ -0,0 +1,21 @@
+package com.bakdata.conquery.quarkus.concepts.filters.providers;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.models.datasets.ColumnDescriptor;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.DurationSumFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.IntegerRangeFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class DurationSumFilterProvider extends AbstractFilterProvider<DurationSumFilterDefinition> {
+	public DurationSumFilterProvider() {
+		super(DurationSumFilterDefinition.class, IntegerRangeFilterValue.class);
+	}
+
+	@Override
+	public FilterResult convert(FilterConversionContext context, DurationSumFilterDefinition payload) {
+		ColumnDescriptor column = requiredColumn(context, payload);
+		return filter(context, payload, IntegerRangeFilterValue.class, 0, null, false, columns(column, optionalColumns(context, payload.getDistinctBy())));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/FlagsFilterProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/FlagsFilterProvider.java
new file mode 100644
index 0000000000..b2d961b130
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/FlagsFilterProvider.java
@@ -0,0 +1,19 @@
+package com.bakdata.conquery.quarkus.concepts.filters.providers;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.FlagsFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.MultiSelectFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class FlagsFilterProvider extends AbstractFilterProvider<FlagsFilterDefinition> {
+	public FlagsFilterProvider() {
+		super(FlagsFilterDefinition.class, MultiSelectFilterValue.class);
+	}
+
+	@Override
+	public FilterResult convert(FilterConversionContext context, FlagsFilterDefinition payload) {
+		return filter(context, payload, MultiSelectFilterValue.class, null, null, false, flagColumns(context, payload.getFlags()));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/NumberFilterProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/NumberFilterProvider.java
new file mode 100644
index 0000000000..91e756e0b6
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/NumberFilterProvider.java
@@ -0,0 +1,25 @@
+package com.bakdata.conquery.quarkus.concepts.filters.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.models.datasets.ColumnDescriptor;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.NumberFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.IntegerRangeFilterValue;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.MoneyRangeFilterValue;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.RealRangeFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class NumberFilterProvider extends AbstractFilterProvider<NumberFilterDefinition> {
+	public NumberFilterProvider() {
+		super(NumberFilterDefinition.class, IntegerRangeFilterValue.class, MoneyRangeFilterValue.class, RealRangeFilterValue.class);
+	}
+
+	@Override
+	public FilterResult convert(FilterConversionContext context, NumberFilterDefinition payload) {
+		ColumnDescriptor column = requiredColumn(context, payload);
+		return filter(context, payload, numericRangeValueType(column), null, null, false, List.of(column));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/PrefixTextFilterProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/PrefixTextFilterProvider.java
new file mode 100644
index 0000000000..ea48c6a042
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/PrefixTextFilterProvider.java
@@ -0,0 +1,21 @@
+package com.bakdata.conquery.quarkus.concepts.filters.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.PrefixTextFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.StringFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class PrefixTextFilterProvider extends AbstractFilterProvider<PrefixTextFilterDefinition> {
+	public PrefixTextFilterProvider() {
+		super(PrefixTextFilterDefinition.class, StringFilterValue.class);
+	}
+
+	@Override
+	public FilterResult convert(FilterConversionContext context, PrefixTextFilterDefinition payload) {
+		return filter(context, payload, StringFilterValue.class, null, null, false, List.of(requiredColumn(context, payload)));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/QuartersInYearFilterProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/QuartersInYearFilterProvider.java
new file mode 100644
index 0000000000..28fe6c519f
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/QuartersInYearFilterProvider.java
@@ -0,0 +1,21 @@
+package com.bakdata.conquery.quarkus.concepts.filters.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.QuartersInYearFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.IntegerRangeFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class QuartersInYearFilterProvider extends AbstractFilterProvider<QuartersInYearFilterDefinition> {
+	public QuartersInYearFilterProvider() {
+		super(QuartersInYearFilterDefinition.class, IntegerRangeFilterValue.class);
+	}
+
+	@Override
+	public FilterResult convert(FilterConversionContext context, QuartersInYearFilterDefinition payload) {
+		return filter(context, payload, IntegerRangeFilterValue.class, 1, 4, false, List.of(requiredColumn(context, payload)));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/SelectFilterProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/SelectFilterProvider.java
new file mode 100644
index 0000000000..a4c52e86df
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/SelectFilterProvider.java
@@ -0,0 +1,27 @@
+package com.bakdata.conquery.quarkus.concepts.filters.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.MultiSelectFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValue;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.BigMultiSelectFilterValue;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.MultiSelectFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class SelectFilterProvider extends AbstractFilterProvider<MultiSelectFilterDefinition> {
+	public SelectFilterProvider() {
+		super(MultiSelectFilterDefinition.class, MultiSelectFilterValue.class, BigMultiSelectFilterValue.class);
+	}
+
+	@Override
+	public FilterResult convert(FilterConversionContext context, MultiSelectFilterDefinition payload) {
+		boolean hasOptions = !options(payload).isEmpty();
+		Class<? extends FilterValue> valueType = hasOptions
+				? MultiSelectFilterValue.class
+				: BigMultiSelectFilterValue.class;
+		return filter(context, payload, valueType, null, null, !hasOptions, List.of(requiredColumn(context, payload)));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/SingleSelectFilterProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/SingleSelectFilterProvider.java
new file mode 100644
index 0000000000..cb942aa9be
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/SingleSelectFilterProvider.java
@@ -0,0 +1,22 @@
+package com.bakdata.conquery.quarkus.concepts.filters.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.SingleSelectFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.SelectFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+// TODO remove this filter or migrate it's FilterValue to StringFilterValue
+@ApplicationScoped
+public class SingleSelectFilterProvider extends AbstractFilterProvider<SingleSelectFilterDefinition> {
+	public SingleSelectFilterProvider() {
+		super(SingleSelectFilterDefinition.class, SelectFilterValue.class);
+	}
+
+	@Override
+	public FilterResult convert(FilterConversionContext context, SingleSelectFilterDefinition payload) {
+		return filter(context, payload, SelectFilterValue.class, null, null, false, List.of(requiredColumn(context, payload)));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/SumFilterProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/SumFilterProvider.java
new file mode 100644
index 0000000000..e8428b39d7
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/providers/SumFilterProvider.java
@@ -0,0 +1,30 @@
+package com.bakdata.conquery.quarkus.concepts.filters.providers;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterConversionContext;
+import com.bakdata.conquery.models.datasets.ColumnDescriptor;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterResult;
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.SumFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.IntegerRangeFilterValue;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.MoneyRangeFilterValue;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.RealRangeFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class SumFilterProvider extends AbstractFilterProvider<SumFilterDefinition> {
+	public SumFilterProvider() {
+		super(SumFilterDefinition.class, IntegerRangeFilterValue.class, MoneyRangeFilterValue.class, RealRangeFilterValue.class);
+	}
+
+	@Override
+	public FilterResult convert(FilterConversionContext context, SumFilterDefinition payload) {
+		ColumnDescriptor column = requiredColumn(context, payload);
+		List<ColumnDescriptor> required = new ArrayList<>(columns(column, optionalColumns(context, payload.getDistinctByColumn())));
+		if (payload.getSubtractColumn() != null && !payload.getSubtractColumn().isBlank()) {
+			required.add(context.requireColumn(payload.getSubtractColumn()));
+		}
+		return filter(context, payload, numericRangeValueType(column), null, null, false, required);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/FilterValue.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/FilterValue.java
new file mode 100644
index 0000000000..6ef8798a2f
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/FilterValue.java
@@ -0,0 +1,18 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values;
+
+import com.bakdata.conquery.quarkus.ids.FilterId;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelBase;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type")
+@Schema(name = "QueryFilterValue", description = "Value assigned to a concept filter in a query. The concrete value model is selected by `type`.", discriminatorProperty = "type")
+@PolymorphicModelBase(
+		schemaName = "QueryFilterValue",
+		description = "Value assigned to a concept filter in a query. The concrete value model is selected by `type`."
+)
+public interface FilterValue {
+
+	@Schema(description = "The filter this value submitted to.")
+	FilterId filter();
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/FilterValueProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/FilterValueProvider.java
new file mode 100644
index 0000000000..76d980856f
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/FilterValueProvider.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values;
+
+import com.bakdata.conquery.quarkus.models.PolymorphicModelTypeProvider;
+
+public interface FilterValueProvider<T extends FilterValue> extends PolymorphicModelTypeProvider<FilterValue, T> {
+
+	default String type() {
+		return typeId();
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/FilterValueRegistry.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/FilterValueRegistry.java
new file mode 100644
index 0000000000..535935223f
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/FilterValueRegistry.java
@@ -0,0 +1,49 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import jakarta.annotation.PostConstruct;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.inject.Instance;
+import jakarta.inject.Inject;
+
+@ApplicationScoped
+public class FilterValueRegistry {
+
+	@Inject
+	Instance<FilterValueProvider<?>> providers;
+
+	private Map<Class<? extends FilterValue>, FilterValueProvider<?>> providersByModelType = Map.of();
+
+	@PostConstruct
+	void init() {
+		Map<Class<? extends FilterValue>, FilterValueProvider<?>> index = new LinkedHashMap<>();
+		for (FilterValueProvider<?> provider : providers) {
+			FilterValueProvider<?> previous = index.put(provider.modelType(), provider);
+			if (previous != null) {
+				throw new IllegalStateException("Duplicate filter value provider for model type " + provider.modelType().getName() + ": " + previous.getClass().getName() + " and " + provider.getClass().getName());
+			}
+		}
+		providersByModelType = Map.copyOf(index);
+	}
+
+	public FilterValueProvider<?> require(FilterValue value) {
+		return require(value.getClass());
+	}
+
+	public FilterValueProvider<?> require(Class<? extends FilterValue> modelType) {
+		FilterValueProvider<?> provider = providersByModelType.get(modelType);
+		if (provider == null) {
+			throw new IllegalArgumentException("No filter value provider registered for " + modelType.getName());
+		}
+		return provider;
+	}
+
+	public FilterValueProvider<?> require(String type) {
+		return providersByModelType.values().stream()
+				.filter(provider -> provider.type().equals(type))
+				.findFirst()
+				.orElseThrow(() -> new IllegalArgumentException("No filter value provider registered for type " + type));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/BigMultiSelectFilterValue.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/BigMultiSelectFilterValue.java
new file mode 100644
index 0000000000..fc8ba94c45
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/BigMultiSelectFilterValue.java
@@ -0,0 +1,15 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.definitions;
+
+import java.util.Set;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValue;
+import com.bakdata.conquery.quarkus.ids.FilterId;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "QueryBigMultiSelectFilterValue", description = "A potentially large set of selected filter values.")
+@PolymorphicModelSubtype(base = FilterValue.class, id = "BIG_MULTI_SELECT")
+public record BigMultiSelectFilterValue(@NotNull FilterId filter, @NotNull @NotEmpty Set<@NotNull String> value) implements FilterValue {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/IntegerFilterRange.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/IntegerFilterRange.java
new file mode 100644
index 0000000000..e01658daea
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/IntegerFilterRange.java
@@ -0,0 +1,7 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.definitions;
+
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "QueryIntegerFilterRange", description = "Inclusive integer range. Either boundary may be omitted.")
+public record IntegerFilterRange(Long min, Long max) {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/IntegerFilterValue.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/IntegerFilterValue.java
new file mode 100644
index 0000000000..08c30d679c
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/IntegerFilterValue.java
@@ -0,0 +1,12 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValue;
+import com.bakdata.conquery.quarkus.ids.FilterId;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotNull;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "QueryIntegerFilterValue", description = "A single integer filter value.")
+@PolymorphicModelSubtype(base = FilterValue.class, id = "INTEGER")
+public record IntegerFilterValue(@NotNull FilterId filter, @NotNull Long value) implements FilterValue {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/IntegerRangeFilterValue.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/IntegerRangeFilterValue.java
new file mode 100644
index 0000000000..6028640cc2
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/IntegerRangeFilterValue.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValue;
+import com.bakdata.conquery.quarkus.ids.FilterId;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "QueryIntegerRangeFilterValue", description = "An integer range filter value.")
+@PolymorphicModelSubtype(base = FilterValue.class, id = "INTEGER_RANGE")
+public record IntegerRangeFilterValue(@NotNull FilterId filter, @Valid @NotNull IntegerFilterRange value) implements FilterValue {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/MoneyRangeFilterValue.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/MoneyRangeFilterValue.java
new file mode 100644
index 0000000000..e6266ebeec
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/MoneyRangeFilterValue.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValue;
+import com.bakdata.conquery.quarkus.ids.FilterId;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "QueryMoneyRangeFilterValue", description = "A monetary range represented in the configured minor currency unit.")
+@PolymorphicModelSubtype(base = FilterValue.class, id = "MONEY_RANGE")
+public record MoneyRangeFilterValue(@NotNull FilterId filter, @Valid @NotNull IntegerFilterRange value) implements FilterValue {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/MultiSelectFilterValue.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/MultiSelectFilterValue.java
new file mode 100644
index 0000000000..83f48b9559
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/MultiSelectFilterValue.java
@@ -0,0 +1,15 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.definitions;
+
+import java.util.Set;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValue;
+import com.bakdata.conquery.quarkus.ids.FilterId;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "QueryMultiSelectFilterValue", description = "A set of selected filter values.")
+@PolymorphicModelSubtype(base = FilterValue.class, id = "MULTI_SELECT")
+public record MultiSelectFilterValue(@NotNull FilterId filter, @NotNull @NotEmpty Set<@NotNull String> value) implements FilterValue {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/RealFilterRange.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/RealFilterRange.java
new file mode 100644
index 0000000000..19acd84701
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/RealFilterRange.java
@@ -0,0 +1,9 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.definitions;
+
+import java.math.BigDecimal;
+
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "QueryRealFilterRange", description = "Inclusive real-number range. Either boundary may be omitted.")
+public record RealFilterRange(BigDecimal min, BigDecimal max) {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/RealFilterValue.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/RealFilterValue.java
new file mode 100644
index 0000000000..c12f553e0c
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/RealFilterValue.java
@@ -0,0 +1,14 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.definitions;
+
+import java.math.BigDecimal;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValue;
+import com.bakdata.conquery.quarkus.ids.FilterId;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotNull;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "QueryRealFilterValue", description = "A single real-number filter value.")
+@PolymorphicModelSubtype(base = FilterValue.class, id = "REAL")
+public record RealFilterValue(@NotNull FilterId filter, @NotNull BigDecimal value) implements FilterValue {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/RealRangeFilterValue.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/RealRangeFilterValue.java
new file mode 100644
index 0000000000..62134d2a3c
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/RealRangeFilterValue.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValue;
+import com.bakdata.conquery.quarkus.ids.FilterId;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "QueryRealRangeFilterValue", description = "A real-number range filter value.")
+@PolymorphicModelSubtype(base = FilterValue.class, id = "REAL_RANGE")
+public record RealRangeFilterValue(@NotNull FilterId filter, @Valid @NotNull RealFilterRange value) implements FilterValue {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/SelectFilterValue.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/SelectFilterValue.java
new file mode 100644
index 0000000000..1a8db9daf0
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/SelectFilterValue.java
@@ -0,0 +1,12 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValue;
+import com.bakdata.conquery.quarkus.ids.FilterId;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotNull;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "QuerySelectFilterValue", description = "A single selected filter value.")
+@PolymorphicModelSubtype(base = FilterValue.class, id = "SELECT")
+public record SelectFilterValue(@NotNull FilterId filter, @NotNull String value) implements FilterValue {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/StringFilterValue.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/StringFilterValue.java
new file mode 100644
index 0000000000..86d185437b
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/definitions/StringFilterValue.java
@@ -0,0 +1,12 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValue;
+import com.bakdata.conquery.quarkus.ids.FilterId;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotNull;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "QueryStringFilterValue", description = "A free-text filter value.")
+@PolymorphicModelSubtype(base = FilterValue.class, id = "STRING")
+public record StringFilterValue(@NotNull FilterId filter, @NotNull String value) implements FilterValue {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/AbstractFilterValueProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/AbstractFilterValueProvider.java
new file mode 100644
index 0000000000..8d7c191c69
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/AbstractFilterValueProvider.java
@@ -0,0 +1,18 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.providers;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValue;
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValueProvider;
+
+abstract class AbstractFilterValueProvider<T extends FilterValue> implements FilterValueProvider<T> {
+
+	private final Class<T> modelType;
+
+	protected AbstractFilterValueProvider(Class<T> modelType) {
+		this.modelType = modelType;
+	}
+
+	@Override
+	public Class<T> modelType() {
+		return modelType;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/BigMultiSelectFilterValueProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/BigMultiSelectFilterValueProvider.java
new file mode 100644
index 0000000000..37f0196cd7
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/BigMultiSelectFilterValueProvider.java
@@ -0,0 +1,12 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.providers;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.BigMultiSelectFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class BigMultiSelectFilterValueProvider extends AbstractFilterValueProvider<BigMultiSelectFilterValue> {
+	public BigMultiSelectFilterValueProvider() {
+		super(BigMultiSelectFilterValue.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/IntegerFilterValueProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/IntegerFilterValueProvider.java
new file mode 100644
index 0000000000..7e6b6dca00
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/IntegerFilterValueProvider.java
@@ -0,0 +1,12 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.providers;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.IntegerFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class IntegerFilterValueProvider extends AbstractFilterValueProvider<IntegerFilterValue> {
+	public IntegerFilterValueProvider() {
+		super(IntegerFilterValue.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/IntegerRangeFilterValueProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/IntegerRangeFilterValueProvider.java
new file mode 100644
index 0000000000..b580b0079b
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/IntegerRangeFilterValueProvider.java
@@ -0,0 +1,12 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.providers;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.IntegerRangeFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class IntegerRangeFilterValueProvider extends AbstractFilterValueProvider<IntegerRangeFilterValue> {
+	public IntegerRangeFilterValueProvider() {
+		super(IntegerRangeFilterValue.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/MoneyRangeFilterValueProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/MoneyRangeFilterValueProvider.java
new file mode 100644
index 0000000000..49a08be1a1
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/MoneyRangeFilterValueProvider.java
@@ -0,0 +1,12 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.providers;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.MoneyRangeFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class MoneyRangeFilterValueProvider extends AbstractFilterValueProvider<MoneyRangeFilterValue> {
+	public MoneyRangeFilterValueProvider() {
+		super(MoneyRangeFilterValue.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/MultiSelectFilterValueProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/MultiSelectFilterValueProvider.java
new file mode 100644
index 0000000000..0e62fc26a9
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/MultiSelectFilterValueProvider.java
@@ -0,0 +1,12 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.providers;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.MultiSelectFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class MultiSelectFilterValueProvider extends AbstractFilterValueProvider<MultiSelectFilterValue> {
+	public MultiSelectFilterValueProvider() {
+		super(MultiSelectFilterValue.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/RealFilterValueProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/RealFilterValueProvider.java
new file mode 100644
index 0000000000..3841338f1b
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/RealFilterValueProvider.java
@@ -0,0 +1,12 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.providers;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.RealFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class RealFilterValueProvider extends AbstractFilterValueProvider<RealFilterValue> {
+	public RealFilterValueProvider() {
+		super(RealFilterValue.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/RealRangeFilterValueProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/RealRangeFilterValueProvider.java
new file mode 100644
index 0000000000..0df564b13a
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/RealRangeFilterValueProvider.java
@@ -0,0 +1,12 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.providers;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.RealRangeFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class RealRangeFilterValueProvider extends AbstractFilterValueProvider<RealRangeFilterValue> {
+	public RealRangeFilterValueProvider() {
+		super(RealRangeFilterValue.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/SelectFilterValueProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/SelectFilterValueProvider.java
new file mode 100644
index 0000000000..ce191b2019
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/SelectFilterValueProvider.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.providers;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.SelectFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+// TODO maybe remove, it may has a different symantic to the frontend than StringFilterValueProvider  
+@ApplicationScoped
+public class SelectFilterValueProvider extends AbstractFilterValueProvider<SelectFilterValue> {
+	public SelectFilterValueProvider() {
+		super(SelectFilterValue.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/StringFilterValueProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/StringFilterValueProvider.java
new file mode 100644
index 0000000000..3b08560280
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/filters/values/providers/StringFilterValueProvider.java
@@ -0,0 +1,12 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values.providers;
+
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.StringFilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class StringFilterValueProvider extends AbstractFilterValueProvider<StringFilterValue> {
+	public StringFilterValueProvider() {
+		super(StringFilterValue.class);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/SelectConversionContext.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/SelectConversionContext.java
new file mode 100644
index 0000000000..9cc050a0d4
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/SelectConversionContext.java
@@ -0,0 +1,61 @@
+package com.bakdata.conquery.quarkus.concepts.selects;
+
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.quarkus.ids.ConnectorId;
+import com.bakdata.conquery.quarkus.ids.IdPartSanitizer;
+import com.bakdata.conquery.quarkus.ids.SelectId;
+import com.bakdata.conquery.quarkus.ids.TableId;
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+
+public record SelectConversionContext(
+		ConnectorId connectorId,
+		TableId tableId,
+		DatasetCatalogRepository.TableRecord table,
+		FallbackReporter fallbackReporter
+) {
+
+	public SelectId selectId(String name) {
+		return new SelectId(connectorId, name);
+	}
+
+	public ColumnId columnId(String value) {
+		if (value == null || value.isBlank()) {
+			throw new IllegalArgumentException("Select column in connector '" + connectorId + "' must not be blank.");
+		}
+		if (value.contains(".")) {
+			throw new IllegalArgumentException("Select column in connector '" + connectorId + "' must be a local column name without dots: " + value);
+		}
+		ColumnId columnId = new ColumnId(tableId, value);
+		if (table.columns().stream().noneMatch(column -> column.id().equals(columnId))) {
+			throw new IllegalArgumentException("Select for connector '" + connectorId + "' references unknown column '" + columnId + "'.");
+		}
+		return columnId;
+	}
+
+	public ColumnType columnType(ColumnId columnId) {
+		return table.columns().stream()
+				.filter(column -> column.id().equals(columnId))
+				.map(DatasetCatalogRepository.ColumnRecord::type)
+				.findFirst()
+				.orElseThrow(() -> new IllegalArgumentException("Unknown column '" + columnId + "'."));
+	}
+
+	public String idPartFromPreferredOrFallback(String preferred, String fallback, String label, String type) {
+		if (preferred != null && !preferred.isBlank()) {
+			return preferred.trim();
+		}
+		String source = Optional.ofNullable(fallback).filter(value -> !value.isBlank())
+				.orElseThrow(() -> new IllegalArgumentException("Select " + type + " must define name or label."));
+		String sanitized = IdPartSanitizer.sanitize(source, label);
+		fallbackReporter.record(label, type, source, sanitized);
+		return sanitized;
+	}
+
+	@FunctionalInterface
+	public interface FallbackReporter {
+		void record(String idType, Object context, String fallbackValue, String sanitized);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/SelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/SelectDefinition.java
new file mode 100644
index 0000000000..79d7300dfc
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/SelectDefinition.java
@@ -0,0 +1,22 @@
+package com.bakdata.conquery.quarkus.concepts.selects;
+
+import com.bakdata.conquery.quarkus.models.PolymorphicModelBase;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@JsonTypeInfo(
+		use = JsonTypeInfo.Id.NAME,
+		include = JsonTypeInfo.As.EXISTING_PROPERTY,
+		property = "type",
+		visible = true,
+		defaultImpl = UnknownSelectDefinition.class
+)
+@Schema(name = "MetadataSelectDefinition", description = "Select definition used in connector metadata. The concrete model is selected by `type`.", discriminatorProperty = "type")
+@PolymorphicModelBase(
+		schemaName = "MetadataSelectDefinition",
+		description = "Select definition used in connector metadata. The concrete model is selected by `type`."
+)
+public interface SelectDefinition {
+
+	String getType();
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/SelectDefinitionAssembler.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/SelectDefinitionAssembler.java
new file mode 100644
index 0000000000..8ab4220488
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/SelectDefinitionAssembler.java
@@ -0,0 +1,62 @@
+package com.bakdata.conquery.quarkus.concepts.selects;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.ids.ConnectorId;
+import com.bakdata.conquery.quarkus.ids.TableId;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import lombok.extern.slf4j.Slf4j;
+
+@ApplicationScoped
+@Slf4j
+public class SelectDefinitionAssembler {
+
+	@Inject
+	SelectDefinitionRegistry registry;
+
+	@Inject
+	ObjectMapper objectMapper;
+
+	public List<DatasetCatalogRepository.Select> assemble(
+			ConnectorId connectorId,
+			TableId tableId,
+			DatasetCatalogRepository.TableRecord table,
+			List<SelectDefinition> definitions,
+			SelectConversionContext.FallbackReporter fallbackReporter,
+			boolean strictSelectTypes
+	) {
+		if (definitions == null) {
+			return List.of();
+		}
+		SelectConversionContext context = new SelectConversionContext(connectorId, tableId, table, fallbackReporter);
+		List<DatasetCatalogRepository.Select> selects = new ArrayList<>();
+		for (SelectDefinition definition : definitions) {
+			assemble(context, definition, strictSelectTypes).ifPresent(selects::add);
+		}
+		return List.copyOf(selects);
+	}
+
+	private Optional<DatasetCatalogRepository.Select> assemble(SelectConversionContext context, SelectDefinition definition, boolean strictSelectTypes) {
+		Optional<SelectDefinitionProvider<?>> provider = registry.find(definition);
+		if (provider.isPresent()) {
+			return Optional.of(convert(context, definition, provider.get()));
+		}
+		String type = definition.getType();
+		String reason = type == null || type.isBlank() ? "missing select type" : "unknown select type '" + type + "'";
+		String message = "Skipping select for connector '" + context.connectorId() + "' because of " + reason + ": " + objectMapper.valueToTree(definition);
+		if (strictSelectTypes) {
+			throw new IllegalStateException(message);
+		}
+		log.warn("{}", message);
+		return Optional.empty();
+	}
+
+	private <T extends SelectDefinition> DatasetCatalogRepository.Select convert(SelectConversionContext context, SelectDefinition definition, SelectDefinitionProvider<T> provider) {
+		return provider.convert(context, provider.modelType().cast(definition));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/SelectDefinitionProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/SelectDefinitionProvider.java
new file mode 100644
index 0000000000..fb6d29379d
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/SelectDefinitionProvider.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.quarkus.concepts.selects;
+
+import com.bakdata.conquery.quarkus.models.PolymorphicModelTypeProvider;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+
+public interface SelectDefinitionProvider<T extends SelectDefinition> extends PolymorphicModelTypeProvider<SelectDefinition, T> {
+
+	DatasetCatalogRepository.Select convert(SelectConversionContext context, T payload);
+
+	default String type() {
+		return typeId();
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/SelectDefinitionRegistry.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/SelectDefinitionRegistry.java
new file mode 100644
index 0000000000..e38e4039fc
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/SelectDefinitionRegistry.java
@@ -0,0 +1,35 @@
+package com.bakdata.conquery.quarkus.concepts.selects;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import jakarta.annotation.PostConstruct;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.inject.Instance;
+import jakarta.inject.Inject;
+
+@ApplicationScoped
+public class SelectDefinitionRegistry {
+
+	@Inject
+	Instance<SelectDefinitionProvider<?>> providers;
+
+	private Map<Class<? extends SelectDefinition>, SelectDefinitionProvider<?>> providersByModelType = Map.of();
+
+	@PostConstruct
+	void init() {
+		Map<Class<? extends SelectDefinition>, SelectDefinitionProvider<?>> index = new LinkedHashMap<>();
+		for (SelectDefinitionProvider<?> provider : providers) {
+			SelectDefinitionProvider<?> previous = index.put(provider.modelType(), provider);
+			if (previous != null) {
+				throw new IllegalStateException("Duplicate select provider for model type " + provider.modelType().getName() + ": " + previous.getClass().getName() + " and " + provider.getClass().getName());
+			}
+		}
+		providersByModelType = Map.copyOf(index);
+	}
+
+	public Optional<SelectDefinitionProvider<?>> find(SelectDefinition definition) {
+		return Optional.ofNullable(providersByModelType.get(definition.getClass()));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/UnknownSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/UnknownSelectDefinition.java
new file mode 100644
index 0000000000..8d61e7f029
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/UnknownSelectDefinition.java
@@ -0,0 +1,32 @@
+package com.bakdata.conquery.quarkus.concepts.selects;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter;
+import com.fasterxml.jackson.annotation.JsonAnySetter;
+
+public final class UnknownSelectDefinition implements SelectDefinition {
+
+	private String type;
+	private final Map<String, Object> properties = new LinkedHashMap<>();
+
+	@Override
+	public String getType() {
+		return type;
+	}
+
+	public void setType(String type) {
+		this.type = type;
+	}
+
+	@JsonAnySetter
+	public void put(String name, Object value) {
+		properties.put(name, value);
+	}
+
+	@JsonAnyGetter
+	public Map<String, Object> properties() {
+		return Map.copyOf(properties);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectConversionContext.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectConversionContext.java
new file mode 100644
index 0000000000..5fcaaefe2d
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectConversionContext.java
@@ -0,0 +1,33 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept;
+
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.ids.ConceptId;
+import com.bakdata.conquery.quarkus.ids.ConceptSelectId;
+import com.bakdata.conquery.quarkus.ids.IdPartSanitizer;
+
+public record ConceptSelectConversionContext(
+		ConceptId conceptId,
+		FallbackReporter fallbackReporter
+) {
+
+	public ConceptSelectId selectId(String name) {
+		return new ConceptSelectId(conceptId, name);
+	}
+
+	public String idPartFromPreferredOrFallback(String preferred, String fallback, String type) {
+		if (preferred != null && !preferred.isBlank()) {
+			return preferred.trim();
+		}
+		String source = Optional.ofNullable(fallback).filter(value -> !value.isBlank())
+				.orElseThrow(() -> new IllegalArgumentException("Concept select " + type + " must define name or label."));
+		String sanitized = IdPartSanitizer.sanitize(source, "concept select id fallback");
+		fallbackReporter.record("concept select id", type, source, sanitized);
+		return sanitized;
+	}
+
+	@FunctionalInterface
+	public interface FallbackReporter {
+		void record(String idType, Object context, String fallbackValue, String sanitized);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectDefinition.java
new file mode 100644
index 0000000000..7a38f3ddf9
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectDefinition.java
@@ -0,0 +1,22 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept;
+
+import com.bakdata.conquery.quarkus.models.PolymorphicModelBase;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@JsonTypeInfo(
+		use = JsonTypeInfo.Id.NAME,
+		include = JsonTypeInfo.As.EXISTING_PROPERTY,
+		property = "type",
+		visible = true,
+		defaultImpl = UnknownConceptSelectDefinition.class
+)
+@Schema(name = "MetadataConceptSelectDefinition", description = "Select definition used at concept level. The concrete model is selected by `type`.", discriminatorProperty = "type")
+@PolymorphicModelBase(
+		schemaName = "MetadataConceptSelectDefinition",
+		description = "Select definition used at concept level. The concrete model is selected by `type`."
+)
+public interface ConceptSelectDefinition {
+
+	String getType();
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectDefinitionAssembler.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectDefinitionAssembler.java
new file mode 100644
index 0000000000..d915a3371a
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectDefinitionAssembler.java
@@ -0,0 +1,59 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.ids.ConceptId;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import lombok.extern.slf4j.Slf4j;
+
+@ApplicationScoped
+@Slf4j
+public class ConceptSelectDefinitionAssembler {
+
+	@Inject
+	ConceptSelectDefinitionRegistry registry;
+
+	@Inject
+	ObjectMapper objectMapper;
+
+	public List<DatasetCatalogRepository.ConceptSelect> assemble(
+			ConceptId conceptId,
+			List<ConceptSelectDefinition> definitions,
+			ConceptSelectConversionContext.FallbackReporter fallbackReporter,
+			boolean strictSelectTypes
+	) {
+		if (definitions == null) {
+			return List.of();
+		}
+		ConceptSelectConversionContext context = new ConceptSelectConversionContext(conceptId, fallbackReporter);
+		List<DatasetCatalogRepository.ConceptSelect> selects = new ArrayList<>();
+		for (ConceptSelectDefinition definition : definitions) {
+			assemble(context, definition, strictSelectTypes).ifPresent(selects::add);
+		}
+		return List.copyOf(selects);
+	}
+
+	private Optional<DatasetCatalogRepository.ConceptSelect> assemble(ConceptSelectConversionContext context, ConceptSelectDefinition definition, boolean strictSelectTypes) {
+		Optional<ConceptSelectDefinitionProvider<?>> provider = registry.find(definition);
+		if (provider.isPresent()) {
+			return Optional.of(convert(context, definition, provider.get()));
+		}
+		String type = definition.getType();
+		String reason = type == null || type.isBlank() ? "missing concept select type" : "unknown concept select type '" + type + "'";
+		String message = "Skipping select for concept '" + context.conceptId() + "' because of " + reason + ": " + objectMapper.valueToTree(definition);
+		if (strictSelectTypes) {
+			throw new IllegalStateException(message);
+		}
+		log.warn("{}", message);
+		return Optional.empty();
+	}
+
+	private <T extends ConceptSelectDefinition> DatasetCatalogRepository.ConceptSelect convert(ConceptSelectConversionContext context, ConceptSelectDefinition definition, ConceptSelectDefinitionProvider<T> provider) {
+		return provider.convert(context, provider.modelType().cast(definition));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectDefinitionProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectDefinitionProvider.java
new file mode 100644
index 0000000000..9ff6e53781
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectDefinitionProvider.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept;
+
+import com.bakdata.conquery.quarkus.models.PolymorphicModelTypeProvider;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+
+public interface ConceptSelectDefinitionProvider<T extends ConceptSelectDefinition> extends PolymorphicModelTypeProvider<ConceptSelectDefinition, T> {
+
+	DatasetCatalogRepository.ConceptSelect convert(ConceptSelectConversionContext context, T payload);
+
+	default String type() {
+		return typeId();
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectDefinitionRegistry.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectDefinitionRegistry.java
new file mode 100644
index 0000000000..1c1d7a8f32
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectDefinitionRegistry.java
@@ -0,0 +1,35 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import jakarta.annotation.PostConstruct;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.inject.Instance;
+import jakarta.inject.Inject;
+
+@ApplicationScoped
+public class ConceptSelectDefinitionRegistry {
+
+	@Inject
+	Instance<ConceptSelectDefinitionProvider<?>> providers;
+
+	private Map<Class<? extends ConceptSelectDefinition>, ConceptSelectDefinitionProvider<?>> providersByModelType = Map.of();
+
+	@PostConstruct
+	void init() {
+		Map<Class<? extends ConceptSelectDefinition>, ConceptSelectDefinitionProvider<?>> index = new LinkedHashMap<>();
+		for (ConceptSelectDefinitionProvider<?> provider : providers) {
+			ConceptSelectDefinitionProvider<?> previous = index.put(provider.modelType(), provider);
+			if (previous != null) {
+				throw new IllegalStateException("Duplicate concept select provider for model type " + provider.modelType().getName() + ": " + previous.getClass().getName() + " and " + provider.getClass().getName());
+			}
+		}
+		providersByModelType = Map.copyOf(index);
+	}
+
+	public Optional<ConceptSelectDefinitionProvider<?>> find(ConceptSelectDefinition definition) {
+		return Optional.ofNullable(providersByModelType.get(definition.getClass()));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/UnknownConceptSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/UnknownConceptSelectDefinition.java
new file mode 100644
index 0000000000..0c150c47ed
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/UnknownConceptSelectDefinition.java
@@ -0,0 +1,32 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter;
+import com.fasterxml.jackson.annotation.JsonAnySetter;
+
+public final class UnknownConceptSelectDefinition implements ConceptSelectDefinition {
+
+	private String type;
+	private final Map<String, Object> properties = new LinkedHashMap<>();
+
+	@Override
+	public String getType() {
+		return type;
+	}
+
+	public void setType(String type) {
+		this.type = type;
+	}
+
+	@JsonAnySetter
+	public void put(String name, Object value) {
+		properties.put(name, value);
+	}
+
+	@JsonAnyGetter
+	public Map<String, Object> properties() {
+		return Map.copyOf(properties);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/AbstractConceptSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/AbstractConceptSelectDefinition.java
new file mode 100644
index 0000000000..403e495e31
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/AbstractConceptSelectDefinition.java
@@ -0,0 +1,28 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectDefinition;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@JsonIgnoreProperties(ignoreUnknown = true)
+public abstract class AbstractConceptSelectDefinition implements ConceptSelectDefinition {
+
+	@Schema(description = "Concept select implementation discriminator.")
+	private String type;
+
+	@Schema(description = "Stable local name used to form the select id. Falls back to the label when omitted.", pattern = "^\\w+$")
+	private String name;
+
+	@Schema(description = "Label displayed to users.")
+	private String label;
+
+	@Schema(description = "Additional explanation displayed for the select.")
+	private String description;
+
+	@Schema(description = "Whether the frontend preselects this select.")
+	private boolean isDefault;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/ConceptValuesConceptSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/ConceptValuesConceptSelectDefinition.java
new file mode 100644
index 0000000000..4f0ec2299d
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/ConceptValuesConceptSelectDefinition.java
@@ -0,0 +1,17 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataConceptValuesConceptSelect", description = "Returns values of matching concept nodes.")
+@PolymorphicModelSubtype(base = ConceptSelectDefinition.class, id = "CONCEPT_VALUES")
+public final class ConceptValuesConceptSelectDefinition extends AbstractConceptSelectDefinition {
+
+	@Schema(description = "Whether concept ids are returned instead of labels.")
+	private boolean asIds;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/EventDateUnionConceptSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/EventDateUnionConceptSelectDefinition.java
new file mode 100644
index 0000000000..878bbc6873
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/EventDateUnionConceptSelectDefinition.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataEventDateUnionConceptSelect", description = "Returns the union of matching event dates.")
+@PolymorphicModelSubtype(base = ConceptSelectDefinition.class, id = "EVENT_DATE_UNION")
+public final class EventDateUnionConceptSelectDefinition extends AbstractConceptSelectDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/EventDurationSumConceptSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/EventDurationSumConceptSelectDefinition.java
new file mode 100644
index 0000000000..bb00a397bf
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/EventDurationSumConceptSelectDefinition.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataEventDurationSumConceptSelect", description = "Returns the total duration of matching events.")
+@PolymorphicModelSubtype(base = ConceptSelectDefinition.class, id = "EVENT_DURATION_SUM")
+public final class EventDurationSumConceptSelectDefinition extends AbstractConceptSelectDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/ExistsConceptSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/ExistsConceptSelectDefinition.java
new file mode 100644
index 0000000000..2bac963a1e
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/ExistsConceptSelectDefinition.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataExistsConceptSelect", description = "Returns whether the concept has any matching event.")
+@PolymorphicModelSubtype(base = ConceptSelectDefinition.class, id = "EXISTS")
+public final class ExistsConceptSelectDefinition extends AbstractConceptSelectDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/QuarterConceptSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/QuarterConceptSelectDefinition.java
new file mode 100644
index 0000000000..faf4208b81
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/definitions/QuarterConceptSelectDefinition.java
@@ -0,0 +1,24 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotNull;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataQuarterConceptSelect", description = "Returns the quarter containing a sampled event date.")
+@PolymorphicModelSubtype(base = ConceptSelectDefinition.class, id = "QUARTER")
+public final class QuarterConceptSelectDefinition extends AbstractConceptSelectDefinition {
+
+	@NotNull
+	private TemporalSampler sample;
+
+	public enum TemporalSampler {
+		EARLIEST,
+		LATEST,
+		RANDOM
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/AbstractConceptSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/AbstractConceptSelectProvider.java
new file mode 100644
index 0000000000..d41b298d33
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/AbstractConceptSelectProvider.java
@@ -0,0 +1,47 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept.providers;
+
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectDefinitionProvider;
+import com.bakdata.conquery.quarkus.concepts.selects.concept.definitions.AbstractConceptSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ConceptSelectId;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+
+abstract class AbstractConceptSelectProvider<T extends AbstractConceptSelectDefinition> implements ConceptSelectDefinitionProvider<T> {
+
+	private final Class<T> modelType;
+
+	protected AbstractConceptSelectProvider(Class<T> modelType) {
+		this.modelType = modelType;
+	}
+
+	@Override
+	public Class<T> modelType() {
+		return modelType;
+	}
+
+	protected DatasetCatalogRepository.ConceptSelect select(ConceptSelectConversionContext context, T payload, DatasetCatalogRepository.SelectResultType resultType) {
+		String name = context.idPartFromPreferredOrFallback(payload.getName(), payload.getLabel(), type());
+		String label = firstNonBlank(payload.getLabel(), payload.getName()).orElse(name);
+		ConceptSelectId id = context.selectId(name);
+		return new DatasetCatalogRepository.ConceptSelect(id, payload, label, payload.getDescription(), payload.isDefault(), type(), resultType);
+	}
+
+	protected DatasetCatalogRepository.SelectResultType primitive(String type) {
+		return DatasetCatalogRepository.SelectResultType.primitive(type);
+	}
+
+	protected DatasetCatalogRepository.SelectResultType list(String elementType) {
+		return DatasetCatalogRepository.SelectResultType.list(primitive(elementType));
+	}
+
+	private Optional<String> firstNonBlank(String... values) {
+		for (String value : values) {
+			if (value != null && !value.isBlank()) {
+				return Optional.of(value.trim());
+			}
+		}
+		return Optional.empty();
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/ConceptValuesConceptSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/ConceptValuesConceptSelectProvider.java
new file mode 100644
index 0000000000..dc2060d137
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/ConceptValuesConceptSelectProvider.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept.providers;
+
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.concept.definitions.ConceptValuesConceptSelectDefinition;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class ConceptValuesConceptSelectProvider extends AbstractConceptSelectProvider<ConceptValuesConceptSelectDefinition> {
+
+	public ConceptValuesConceptSelectProvider() {
+		super(ConceptValuesConceptSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.ConceptSelect convert(ConceptSelectConversionContext context, ConceptValuesConceptSelectDefinition payload) {
+		return select(context, payload, list("STRING"));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/EventDateUnionConceptSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/EventDateUnionConceptSelectProvider.java
new file mode 100644
index 0000000000..57d573f8e4
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/EventDateUnionConceptSelectProvider.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept.providers;
+
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.concept.definitions.EventDateUnionConceptSelectDefinition;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class EventDateUnionConceptSelectProvider extends AbstractConceptSelectProvider<EventDateUnionConceptSelectDefinition> {
+
+	public EventDateUnionConceptSelectProvider() {
+		super(EventDateUnionConceptSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.ConceptSelect convert(ConceptSelectConversionContext context, EventDateUnionConceptSelectDefinition payload) {
+		return select(context, payload, list("DATE_RANGE"));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/EventDurationSumConceptSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/EventDurationSumConceptSelectProvider.java
new file mode 100644
index 0000000000..1faaf59291
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/EventDurationSumConceptSelectProvider.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept.providers;
+
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.concept.definitions.EventDurationSumConceptSelectDefinition;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class EventDurationSumConceptSelectProvider extends AbstractConceptSelectProvider<EventDurationSumConceptSelectDefinition> {
+
+	public EventDurationSumConceptSelectProvider() {
+		super(EventDurationSumConceptSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.ConceptSelect convert(ConceptSelectConversionContext context, EventDurationSumConceptSelectDefinition payload) {
+		return select(context, payload, primitive("INTEGER"));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/ExistsConceptSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/ExistsConceptSelectProvider.java
new file mode 100644
index 0000000000..78ee8b9876
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/ExistsConceptSelectProvider.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept.providers;
+
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.concept.definitions.ExistsConceptSelectDefinition;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class ExistsConceptSelectProvider extends AbstractConceptSelectProvider<ExistsConceptSelectDefinition> {
+
+	public ExistsConceptSelectProvider() {
+		super(ExistsConceptSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.ConceptSelect convert(ConceptSelectConversionContext context, ExistsConceptSelectDefinition payload) {
+		return select(context, payload, primitive("BOOLEAN"));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/QuarterConceptSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/QuarterConceptSelectProvider.java
new file mode 100644
index 0000000000..74ee592184
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/concept/providers/QuarterConceptSelectProvider.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept.providers;
+
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.concept.definitions.QuarterConceptSelectDefinition;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class QuarterConceptSelectProvider extends AbstractConceptSelectProvider<QuarterConceptSelectDefinition> {
+
+	public QuarterConceptSelectProvider() {
+		super(QuarterConceptSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.ConceptSelect convert(ConceptSelectConversionContext context, QuarterConceptSelectDefinition payload) {
+		return select(context, payload, primitive("STRING"));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/AbstractSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/AbstractSelectDefinition.java
new file mode 100644
index 0000000000..b7da7dcb3b
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/AbstractSelectDefinition.java
@@ -0,0 +1,28 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@JsonIgnoreProperties(ignoreUnknown = true)
+public abstract class AbstractSelectDefinition implements SelectDefinition {
+
+	@Schema(description = "Select implementation discriminator.")
+	private String type;
+
+	@Schema(description = "Stable local name used to form the select id. Falls back to the label when omitted.", pattern = "^\\w+$")
+	private String name;
+
+	@Schema(description = "Label displayed to users.")
+	private String label;
+
+	@Schema(description = "Additional explanation displayed for the select.")
+	private String description;
+
+	@Schema(description = "Whether the frontend preselects this select.")
+	private boolean isDefault;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/CountQuartersSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/CountQuartersSelectDefinition.java
new file mode 100644
index 0000000000..fe6d0276dd
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/CountQuartersSelectDefinition.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataCountQuartersSelect", description = "Counts distinct quarters covered by dates or date ranges.")
+@PolymorphicModelSubtype(base = SelectDefinition.class, id = "COUNT_QUARTERS")
+public final class CountQuartersSelectDefinition extends DateRangeSelectDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/CountSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/CountSelectDefinition.java
new file mode 100644
index 0000000000..e46c484872
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/CountSelectDefinition.java
@@ -0,0 +1,21 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataCountSelect", description = "Counts matching values or events.")
+@PolymorphicModelSubtype(base = SelectDefinition.class, id = "COUNT")
+public final class CountSelectDefinition extends AbstractSelectDefinition {
+	private boolean distinct;
+	private List<String> distinctByColumn;
+	@NotBlank
+	private String column;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/DateDistanceSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/DateDistanceSelectDefinition.java
new file mode 100644
index 0000000000..4f11a5fb25
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/DateDistanceSelectDefinition.java
@@ -0,0 +1,17 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import java.time.temporal.ChronoUnit;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataDateDistanceSelect", description = "Calculates a date distance in the configured unit.")
+@PolymorphicModelSubtype(base = SelectDefinition.class, id = "DATE_DISTANCE")
+public final class DateDistanceSelectDefinition extends SingleColumnSelectDefinition {
+	private ChronoUnit timeUnit = ChronoUnit.YEARS;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/DateRangeSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/DateRangeSelectDefinition.java
new file mode 100644
index 0000000000..e03fc93d0a
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/DateRangeSelectDefinition.java
@@ -0,0 +1,19 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+public abstract class DateRangeSelectDefinition extends AbstractSelectDefinition {
+
+	@Schema(description = "Local DATE_RANGE column; alternatively use startColumn and endColumn.")
+	private String column;
+
+	@Schema(description = "Local range start column.")
+	private String startColumn;
+
+	@Schema(description = "Local range end column.")
+	private String endColumn;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/DateUnionSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/DateUnionSelectDefinition.java
new file mode 100644
index 0000000000..076df3581b
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/DateUnionSelectDefinition.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataDateUnionSelect", description = "Returns the union of selected date ranges.")
+@PolymorphicModelSubtype(base = SelectDefinition.class, id = "DATE_UNION")
+public final class DateUnionSelectDefinition extends DateRangeSelectDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/DistinctSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/DistinctSelectDefinition.java
new file mode 100644
index 0000000000..440576856a
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/DistinctSelectDefinition.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataDistinctSelect", description = "Selects all distinct values of a column.")
+@PolymorphicModelSubtype(base = SelectDefinition.class, id = "DISTINCT")
+public final class DistinctSelectDefinition extends MappableSelectDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/DurationSumSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/DurationSumSelectDefinition.java
new file mode 100644
index 0000000000..0380de0b65
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/DurationSumSelectDefinition.java
@@ -0,0 +1,17 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataDurationSumSelect", description = "Sums durations of selected date ranges.")
+@PolymorphicModelSubtype(base = SelectDefinition.class, id = "DURATION_SUM")
+public final class DurationSumSelectDefinition extends DateRangeSelectDefinition {
+	private List<String> distinctBy;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/FirstSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/FirstSelectDefinition.java
new file mode 100644
index 0000000000..7c663ba76c
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/FirstSelectDefinition.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataFirstSelect", description = "Selects the first value of a column.")
+@PolymorphicModelSubtype(base = SelectDefinition.class, id = "FIRST")
+public final class FirstSelectDefinition extends MappableSelectDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/FlagsSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/FlagsSelectDefinition.java
new file mode 100644
index 0000000000..d63d7e109c
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/FlagsSelectDefinition.java
@@ -0,0 +1,19 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import java.util.Map;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotEmpty;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataFlagsSelect", description = "Returns labels for matching boolean flag columns.")
+@PolymorphicModelSubtype(base = SelectDefinition.class, id = "FLAGS")
+public final class FlagsSelectDefinition extends AbstractSelectDefinition {
+	@NotEmpty
+	private Map<String, String> flags;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/LastSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/LastSelectDefinition.java
new file mode 100644
index 0000000000..f7eea6c21a
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/LastSelectDefinition.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataLastSelect", description = "Selects the last value of a column.")
+@PolymorphicModelSubtype(base = SelectDefinition.class, id = "LAST")
+public final class LastSelectDefinition extends MappableSelectDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/MappableSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/MappableSelectDefinition.java
new file mode 100644
index 0000000000..ecbe82fa19
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/MappableSelectDefinition.java
@@ -0,0 +1,19 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+public abstract class MappableSelectDefinition extends SingleColumnSelectDefinition {
+
+	@Schema(description = "Optional mapping applied to selected values.")
+	private String mapping;
+
+	@Schema(description = "Optional substring range.")
+	private IntegerRangeDefinition substring;
+
+	public record IntegerRangeDefinition(Integer min, Integer max) {
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/PrefixSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/PrefixSelectDefinition.java
new file mode 100644
index 0000000000..4500bbbe13
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/PrefixSelectDefinition.java
@@ -0,0 +1,17 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import jakarta.validation.constraints.NotNull;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataPrefixSelect", description = "Returns values prefixed with a configured string.")
+@PolymorphicModelSubtype(base = SelectDefinition.class, id = "PREFIX")
+public final class PrefixSelectDefinition extends SingleColumnSelectDefinition {
+	@NotNull
+	private String prefix;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/QuartersInYearSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/QuartersInYearSelectDefinition.java
new file mode 100644
index 0000000000..28eaa75775
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/QuartersInYearSelectDefinition.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataQuartersInYearSelect", description = "Counts quarters with matching events per year.")
+@PolymorphicModelSubtype(base = SelectDefinition.class, id = "QUARTERS_IN_YEAR")
+public final class QuartersInYearSelectDefinition extends SingleColumnSelectDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/RandomSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/RandomSelectDefinition.java
new file mode 100644
index 0000000000..8379f5f3a2
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/RandomSelectDefinition.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Schema(name = "MetadataRandomSelect", description = "Selects one value of a column.")
+@PolymorphicModelSubtype(base = SelectDefinition.class, id = "RANDOM")
+public final class RandomSelectDefinition extends MappableSelectDefinition {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/SingleColumnSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/SingleColumnSelectDefinition.java
new file mode 100644
index 0000000000..f9c247cc7a
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/SingleColumnSelectDefinition.java
@@ -0,0 +1,18 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+public abstract class SingleColumnSelectDefinition extends AbstractSelectDefinition {
+
+	@NotBlank
+	@Schema(description = "Local name of the selected column.")
+	private String column;
+
+	@Schema(description = "Whether values form a bounded categorical set.")
+	private boolean categorical;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/SumSelectDefinition.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/SumSelectDefinition.java
new file mode 100644
index 0000000000..359a518d61
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/definitions/SumSelectDefinition.java
@@ -0,0 +1,18 @@
+package com.bakdata.conquery.quarkus.concepts.selects.definitions;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.bakdata.conquery.quarkus.models.PolymorphicModelSubtype;
+import lombok.Getter;
+import lombok.Setter;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+@Getter
+@Setter
+@Schema(name = "MetadataSumSelect", description = "Sums a numeric column, optionally subtracting another column.")
+@PolymorphicModelSubtype(base = SelectDefinition.class, id = "SUM")
+public final class SumSelectDefinition extends SingleColumnSelectDefinition {
+	private String subtractColumn;
+	private List<String> distinctByColumn;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/AbstractMappableSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/AbstractMappableSelectProvider.java
new file mode 100644
index 0000000000..13edf5f305
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/AbstractMappableSelectProvider.java
@@ -0,0 +1,27 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.MappableSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+
+abstract class AbstractMappableSelectProvider<T extends MappableSelectDefinition> extends AbstractSingleColumnSelectProvider<T> {
+
+	protected AbstractMappableSelectProvider(Class<T> payloadType) {
+		super(payloadType);
+	}
+
+	protected DatasetCatalogRepository.Select convertMapped(SelectConversionContext context, T payload) {
+		ColumnId column = context.columnId(payload.getColumn());
+		if (payload.getMapping() != null || payload.getSubstring() != null) {
+			requireColumnType(context, column, ColumnType.STRING);
+		}
+		DatasetCatalogRepository.SelectResultType result = payload.getMapping() == null
+				? resultType(context, column)
+				: primitive("STRING");
+		return select(context, payload, result, List.of(column));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/AbstractSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/AbstractSelectProvider.java
new file mode 100644
index 0000000000..6e276f654f
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/AbstractSelectProvider.java
@@ -0,0 +1,107 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinitionProvider;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.AbstractSelectDefinition;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.DateRangeSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.quarkus.ids.SelectId;
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+
+abstract class AbstractSelectProvider<T extends AbstractSelectDefinition> implements SelectDefinitionProvider<T> {
+
+	private final Class<T> modelType;
+
+	protected AbstractSelectProvider(Class<T> modelType) {
+		this.modelType = modelType;
+	}
+
+	@Override
+	public Class<T> modelType() {
+		return modelType;
+	}
+
+	protected DatasetCatalogRepository.Select select(
+			SelectConversionContext context,
+			T payload,
+			DatasetCatalogRepository.SelectResultType resultType,
+			List<ColumnId> requiredColumns
+	) {
+		String name = context.idPartFromPreferredOrFallback(payload.getName(), payload.getLabel(), "select id", type());
+		String label = firstNonBlank(payload.getLabel(), payload.getName()).orElse(name);
+		SelectId id = context.selectId(name);
+		return new DatasetCatalogRepository.Select(id, payload, label, payload.getDescription(), payload.isDefault(), type(), resultType, requiredColumns);
+	}
+
+	protected List<ColumnId> optionalColumns(SelectConversionContext context, List<String> columns) {
+		if (columns == null) {
+			return List.of();
+		}
+		return columns.stream().map(context::columnId).toList();
+	}
+
+	protected List<ColumnId> dateRangeColumns(SelectConversionContext context, DateRangeSelectDefinition payload) {
+		boolean hasColumn = isPresent(payload.getColumn());
+		boolean hasStart = isPresent(payload.getStartColumn());
+		boolean hasEnd = isPresent(payload.getEndColumn());
+		if (hasColumn == (hasStart || hasEnd) || hasStart != hasEnd) {
+			throw new IllegalArgumentException("Select " + type() + " must define either column or both startColumn and endColumn.");
+		}
+		if (hasColumn) {
+			return List.of(context.columnId(payload.getColumn()));
+		}
+		return List.of(context.columnId(payload.getStartColumn()), context.columnId(payload.getEndColumn()));
+	}
+
+	protected List<ColumnId> append(List<ColumnId> first, List<ColumnId> second) {
+		List<ColumnId> columns = new ArrayList<>(first);
+		columns.addAll(second);
+		return List.copyOf(columns);
+	}
+
+	protected DatasetCatalogRepository.SelectResultType resultType(SelectConversionContext context, ColumnId column) {
+		return DatasetCatalogRepository.SelectResultType.primitive(context.columnType(column).name());
+	}
+
+	protected void requireColumnType(SelectConversionContext context, ColumnId column, ColumnType... accepted) {
+		ColumnType actual = context.columnType(column);
+		if (!Set.of(accepted).contains(actual)) {
+			throw new IllegalArgumentException("Select " + type() + " column '" + column + "' has type " + actual + ", expected one of " + Set.of(accepted) + ".");
+		}
+	}
+
+	protected void requireDateRangeTypes(SelectConversionContext context, List<ColumnId> columns) {
+		if (columns.size() == 1) {
+			requireColumnType(context, columns.getFirst(), ColumnType.DATE, ColumnType.DATE_RANGE);
+			return;
+		}
+		columns.forEach(column -> requireColumnType(context, column, ColumnType.DATE));
+	}
+
+	protected DatasetCatalogRepository.SelectResultType primitive(String type) {
+		return DatasetCatalogRepository.SelectResultType.primitive(type);
+	}
+
+	protected DatasetCatalogRepository.SelectResultType list(String elementType) {
+		return DatasetCatalogRepository.SelectResultType.list(primitive(elementType));
+	}
+
+	private boolean isPresent(String value) {
+		return value != null && !value.isBlank();
+	}
+
+	private Optional<String> firstNonBlank(String... values) {
+		for (String value : values) {
+			if (value != null && !value.isBlank()) {
+				return Optional.of(value.trim());
+			}
+		}
+		return Optional.empty();
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/AbstractSingleColumnSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/AbstractSingleColumnSelectProvider.java
new file mode 100644
index 0000000000..75b6e18aa8
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/AbstractSingleColumnSelectProvider.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.SingleColumnSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+
+abstract class AbstractSingleColumnSelectProvider<T extends SingleColumnSelectDefinition> extends AbstractSelectProvider<T> {
+
+	protected AbstractSingleColumnSelectProvider(Class<T> payloadType) {
+		super(payloadType);
+	}
+
+	protected DatasetCatalogRepository.Select convertColumn(SelectConversionContext context, T payload) {
+		ColumnId column = context.columnId(payload.getColumn());
+		return select(context, payload, resultType(context, column), List.of(column));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/CountQuartersSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/CountQuartersSelectProvider.java
new file mode 100644
index 0000000000..fdb89e6061
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/CountQuartersSelectProvider.java
@@ -0,0 +1,25 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.CountQuartersSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class CountQuartersSelectProvider extends AbstractSelectProvider<CountQuartersSelectDefinition> {
+
+	public CountQuartersSelectProvider() {
+		super(CountQuartersSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.Select convert(SelectConversionContext context, CountQuartersSelectDefinition payload) {
+		List<ColumnId> columns = dateRangeColumns(context, payload);
+		requireDateRangeTypes(context, columns);
+		return select(context, payload, primitive("INTEGER"), columns);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/CountSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/CountSelectProvider.java
new file mode 100644
index 0000000000..9600ac0a6b
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/CountSelectProvider.java
@@ -0,0 +1,27 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.CountSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class CountSelectProvider extends AbstractSelectProvider<CountSelectDefinition> {
+
+	public CountSelectProvider() {
+		super(CountSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.Select convert(SelectConversionContext context, CountSelectDefinition payload) {
+		List<ColumnId> columns = new ArrayList<>();
+		columns.add(context.columnId(payload.getColumn()));
+		columns.addAll(optionalColumns(context, payload.getDistinctByColumn()));
+		return select(context, payload, primitive("INTEGER"), columns);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/DateDistanceSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/DateDistanceSelectProvider.java
new file mode 100644
index 0000000000..8bcf8ba7e3
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/DateDistanceSelectProvider.java
@@ -0,0 +1,26 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.DateDistanceSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class DateDistanceSelectProvider extends AbstractSingleColumnSelectProvider<DateDistanceSelectDefinition> {
+
+	public DateDistanceSelectProvider() {
+		super(DateDistanceSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.Select convert(SelectConversionContext context, DateDistanceSelectDefinition payload) {
+		ColumnId column = context.columnId(payload.getColumn());
+		requireColumnType(context, column, ColumnType.DATE, ColumnType.DATE_RANGE);
+		return select(context, payload, primitive("INTEGER"), List.of(column));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/DateUnionSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/DateUnionSelectProvider.java
new file mode 100644
index 0000000000..444a877d34
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/DateUnionSelectProvider.java
@@ -0,0 +1,25 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.DateUnionSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class DateUnionSelectProvider extends AbstractSelectProvider<DateUnionSelectDefinition> {
+
+	public DateUnionSelectProvider() {
+		super(DateUnionSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.Select convert(SelectConversionContext context, DateUnionSelectDefinition payload) {
+		List<ColumnId> columns = dateRangeColumns(context, payload);
+		requireDateRangeTypes(context, columns);
+		return select(context, payload, list("DATE_RANGE"), columns);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/DistinctSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/DistinctSelectProvider.java
new file mode 100644
index 0000000000..4c1f51e412
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/DistinctSelectProvider.java
@@ -0,0 +1,31 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.DistinctSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class DistinctSelectProvider extends AbstractMappableSelectProvider<DistinctSelectDefinition> {
+
+	public DistinctSelectProvider() {
+		super(DistinctSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.Select convert(SelectConversionContext context, DistinctSelectDefinition payload) {
+		ColumnId column = context.columnId(payload.getColumn());
+		if (payload.getMapping() != null || payload.getSubstring() != null) {
+			requireColumnType(context, column, ColumnType.STRING);
+		}
+		DatasetCatalogRepository.SelectResultType elementType = payload.getMapping() == null
+				? resultType(context, column)
+				: primitive("STRING");
+		return select(context, payload, DatasetCatalogRepository.SelectResultType.list(elementType), List.of(column));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/DurationSumSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/DurationSumSelectProvider.java
new file mode 100644
index 0000000000..0ac3961060
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/DurationSumSelectProvider.java
@@ -0,0 +1,25 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.DurationSumSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class DurationSumSelectProvider extends AbstractSelectProvider<DurationSumSelectDefinition> {
+
+	public DurationSumSelectProvider() {
+		super(DurationSumSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.Select convert(SelectConversionContext context, DurationSumSelectDefinition payload) {
+		List<ColumnId> rangeColumns = dateRangeColumns(context, payload);
+		requireDateRangeTypes(context, rangeColumns);
+		return select(context, payload, primitive("INTEGER"), append(rangeColumns, optionalColumns(context, payload.getDistinctBy())));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/FirstSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/FirstSelectProvider.java
new file mode 100644
index 0000000000..21369a7fd3
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/FirstSelectProvider.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.FirstSelectDefinition;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class FirstSelectProvider extends AbstractMappableSelectProvider<FirstSelectDefinition> {
+
+	public FirstSelectProvider() {
+		super(FirstSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.Select convert(SelectConversionContext context, FirstSelectDefinition payload) {
+		return convertMapped(context, payload);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/FlagsSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/FlagsSelectProvider.java
new file mode 100644
index 0000000000..4025e1795d
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/FlagsSelectProvider.java
@@ -0,0 +1,26 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.FlagsSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class FlagsSelectProvider extends AbstractSelectProvider<FlagsSelectDefinition> {
+
+	public FlagsSelectProvider() {
+		super(FlagsSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.Select convert(SelectConversionContext context, FlagsSelectDefinition payload) {
+		List<ColumnId> columns = payload.getFlags().values().stream().map(context::columnId).toList();
+		columns.forEach(column -> requireColumnType(context, column, ColumnType.BOOLEAN));
+		return select(context, payload, list("STRING"), columns);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/LastSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/LastSelectProvider.java
new file mode 100644
index 0000000000..6959ef10d9
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/LastSelectProvider.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.LastSelectDefinition;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class LastSelectProvider extends AbstractMappableSelectProvider<LastSelectDefinition> {
+
+	public LastSelectProvider() {
+		super(LastSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.Select convert(SelectConversionContext context, LastSelectDefinition payload) {
+		return convertMapped(context, payload);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/PrefixSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/PrefixSelectProvider.java
new file mode 100644
index 0000000000..2ec84afc28
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/PrefixSelectProvider.java
@@ -0,0 +1,26 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.PrefixSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class PrefixSelectProvider extends AbstractSingleColumnSelectProvider<PrefixSelectDefinition> {
+
+	public PrefixSelectProvider() {
+		super(PrefixSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.Select convert(SelectConversionContext context, PrefixSelectDefinition payload) {
+		ColumnId column = context.columnId(payload.getColumn());
+		requireColumnType(context, column, ColumnType.STRING);
+		return select(context, payload, list("STRING"), List.of(column));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/QuartersInYearSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/QuartersInYearSelectProvider.java
new file mode 100644
index 0000000000..90a1eeacc5
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/QuartersInYearSelectProvider.java
@@ -0,0 +1,26 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.QuartersInYearSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class QuartersInYearSelectProvider extends AbstractSingleColumnSelectProvider<QuartersInYearSelectDefinition> {
+
+	public QuartersInYearSelectProvider() {
+		super(QuartersInYearSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.Select convert(SelectConversionContext context, QuartersInYearSelectDefinition payload) {
+		ColumnId column = context.columnId(payload.getColumn());
+		requireColumnType(context, column, ColumnType.DATE, ColumnType.DATE_RANGE);
+		return select(context, payload, primitive("INTEGER"), List.of(column));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/RandomSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/RandomSelectProvider.java
new file mode 100644
index 0000000000..5d07d148dc
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/RandomSelectProvider.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.RandomSelectDefinition;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class RandomSelectProvider extends AbstractMappableSelectProvider<RandomSelectDefinition> {
+
+	public RandomSelectProvider() {
+		super(RandomSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.Select convert(SelectConversionContext context, RandomSelectDefinition payload) {
+		return convertMapped(context, payload);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/SumSelectProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/SumSelectProvider.java
new file mode 100644
index 0000000000..9a4316641c
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/concepts/selects/providers/SumSelectProvider.java
@@ -0,0 +1,43 @@
+package com.bakdata.conquery.quarkus.concepts.selects.providers;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.SelectConversionContext;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.SumSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class SumSelectProvider extends AbstractSingleColumnSelectProvider<SumSelectDefinition> {
+
+	public SumSelectProvider() {
+		super(SumSelectDefinition.class);
+	}
+
+
+	@Override
+	public DatasetCatalogRepository.Select convert(SelectConversionContext context, SumSelectDefinition payload) {
+		ColumnId column = context.columnId(payload.getColumn());
+		requireColumnType(
+				context,
+				column,
+				ColumnType.INTEGER,
+				ColumnType.MONEY,
+				ColumnType.DECIMAL,
+				ColumnType.REAL
+		);
+		List<ColumnId> columns = new ArrayList<>(List.of(column));
+		if (payload.getSubtractColumn() != null && !payload.getSubtractColumn().isBlank()) {
+			ColumnId subtractColumn = context.columnId(payload.getSubtractColumn());
+			if (context.columnType(subtractColumn) != context.columnType(column)) {
+				throw new IllegalArgumentException("Select SUM columns must have the same type.");
+			}
+			columns.add(subtractColumn);
+		}
+		columns.addAll(optionalColumns(context, payload.getDistinctByColumn()));
+		return select(context, payload, resultType(context, column), columns);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/ConceptsRuntimeConfig.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/ConceptsRuntimeConfig.java
new file mode 100644
index 0000000000..ee49adba69
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/ConceptsRuntimeConfig.java
@@ -0,0 +1,37 @@
+package com.bakdata.conquery.quarkus.config;
+
+import java.util.List;
+import java.util.Optional;
+
+import io.smallrye.config.ConfigMapping;
+
+@ConfigMapping(prefix = "conquery")
+public interface ConceptsRuntimeConfig {
+	/**
+	 * Static root concept definitions used when no generated metadata folder is mounted.
+	 */
+	Optional<List<ConceptEntry>> concepts();
+
+	interface ConceptEntry {
+		/**
+		 * Concept id as exposed to the frontend API.
+		 */
+		String id();
+
+		/**
+		 * Human-readable concept label shown in the concept tree.
+		 */
+		String label();
+
+		/**
+		 * Human-readable concept description shown in the concept tree.
+		 */
+		String description();
+
+
+		/**
+		 * Dataset id this concept belongs to.
+		 */
+		String dataset();
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/DatasetMetadataRuntimeConfig.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/DatasetMetadataRuntimeConfig.java
new file mode 100644
index 0000000000..484a167f4e
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/DatasetMetadataRuntimeConfig.java
@@ -0,0 +1,39 @@
+package com.bakdata.conquery.quarkus.config;
+
+import java.util.List;
+import java.util.Optional;
+
+import io.smallrye.config.ConfigMapping;
+import io.smallrye.config.WithDefault;
+
+@ConfigMapping(prefix = "conquery.metadata")
+public interface DatasetMetadataRuntimeConfig {
+
+	/**
+	 * Enables startup ingestion of generated dataset metadata folders.
+	 */
+	@WithDefault("false")
+	boolean enabled();
+
+	/**
+	 * Base directory that contains generated dataset metadata folders.
+	 */
+	Optional<String> rootPath();
+
+	/**
+	 * Folder names or absolute paths to ingest as static dataset metadata.
+	 */
+	Optional<List<String>> folders();
+
+	/**
+	 * Fails metadata ingestion when a connector filter type has no registered provider.
+	 */
+	@WithDefault("true")
+	boolean strictFilterTypes();
+
+	/**
+	 * Fails metadata ingestion when a connector select type has no registered provider.
+	 */
+	@WithDefault("true")
+	boolean strictSelectTypes();
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/DatasetsRuntimeConfig.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/DatasetsRuntimeConfig.java
new file mode 100644
index 0000000000..0b7127c960
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/DatasetsRuntimeConfig.java
@@ -0,0 +1,26 @@
+package com.bakdata.conquery.quarkus.config;
+
+import java.util.List;
+import java.util.Optional;
+
+import io.smallrye.config.ConfigMapping;
+
+@ConfigMapping(prefix = "conquery")
+public interface DatasetsRuntimeConfig {
+	/**
+	 * Static dataset definitions used when no generated metadata folder is mounted.
+	 */
+	Optional<List<DatasetEntry>> datasets();
+
+	interface DatasetEntry {
+		/**
+		 * Stable dataset id used in API paths and dataset-scoped storage.
+		 */
+		String id();
+
+		/**
+		 * Human-readable dataset label shown in frontend dataset selection.
+		 */
+		String label();
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/EntityPreviewRuntimeConfig.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/EntityPreviewRuntimeConfig.java
new file mode 100644
index 0000000000..ac80c963ed
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/EntityPreviewRuntimeConfig.java
@@ -0,0 +1,45 @@
+package com.bakdata.conquery.quarkus.config;
+
+import java.util.List;
+import java.util.Optional;
+
+import io.smallrye.config.ConfigMapping;
+import io.smallrye.config.WithName;
+
+@ConfigMapping(prefix = "conquery.entity-preview")
+public interface EntityPreviewRuntimeConfig {
+
+	/**
+	 * All entity preview sources available for frontend previews.
+	 */
+	@WithName("all")
+	List<Source> allSources();
+
+	/**
+	 * Entity preview sources selected by default.
+	 */
+	@WithName("default")
+	List<Source> defaultSources();
+
+	/**
+	 * Optional concept id used as the entry point for entity preview search.
+	 */
+	Optional<String> searchConcept();
+
+	/**
+	 * Optional comma-separated list of filter ids available for entity preview search.
+	 */
+	Optional<String> searchFilters();
+
+	interface Source {
+		/**
+		 * Stable source id used by the frontend.
+		 */
+		String name();
+
+		/**
+		 * Human-readable source label.
+		 */
+		String label();
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/FormQueriesRuntimeConfig.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/FormQueriesRuntimeConfig.java
new file mode 100644
index 0000000000..b0baf10a72
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/FormQueriesRuntimeConfig.java
@@ -0,0 +1,15 @@
+package com.bakdata.conquery.quarkus.config;
+
+import java.util.List;
+
+import io.smallrye.config.ConfigMapping;
+import io.smallrye.config.WithDefault;
+
+@ConfigMapping(prefix = "conquery.form-queries")
+public interface FormQueriesRuntimeConfig {
+	/**
+	 * Classpath resources containing frontend form query configuration payloads.
+	 */
+	@WithDefault("forms/export_form.frontend_conf.json,forms/table_export_form.frontend_conf.json")
+	List<String> resources();
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/FrontendConfigResource.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/FrontendConfigResource.java
new file mode 100644
index 0000000000..aa51af3fdb
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/FrontendConfigResource.java
@@ -0,0 +1,90 @@
+package com.bakdata.conquery.quarkus.config;
+
+import java.time.Year;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Optional;
+
+import io.quarkus.info.BuildInfo;
+import jakarta.enterprise.inject.Instance;
+import jakarta.inject.Inject;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+
+@Path("/api/config")
+@Produces(MediaType.APPLICATION_JSON)
+public class FrontendConfigResource {
+	@Inject
+	Instance<BuildInfo> buildInfo;
+
+	@Inject
+	FrontendRuntimeConfig frontendConfig;
+
+	@GET
+	@Path("/frontend")
+	public FrontendConfigurationResponse getFrontendConfig() {
+
+		FrontendRuntimeConfig.Currency currencyConfig = frontendConfig.currency();
+		FrontendConfigurationResponse.CurrencyConfigResponse currency =
+				new FrontendConfigurationResponse.CurrencyConfigResponse(
+						currencyConfig.unit(),
+						currencyConfig.thousandSeparator(),
+						currencyConfig.decimalSeparator(),
+						currencyConfig.decimalScale()
+				);
+
+		
+		FrontendRuntimeConfig.QueryUpload queryUploadConfig = frontendConfig.queryUpload();
+		List<FrontendConfigurationResponse.ColumnConfigResponse> configuredIds =
+				queryUploadConfig.ids()
+								 .orElse(List.of())
+								 .stream()
+								 .map(id -> new FrontendConfigurationResponse.ColumnConfigResponse(
+										 id.name(),
+										 id.field(),
+										 Optional.ofNullable(id.label()).orElse(Map.of(Locale.ROOT.toString(), "result")),
+										 id.primaryId(),
+										 id.print()
+								 ))
+								 .toList();
+
+		FrontendConfigurationResponse.IdColumnConfigResponse queryUpload =
+				new FrontendConfigurationResponse.IdColumnConfigResponse(
+						queryUploadConfig.table(),
+						configuredIds.isEmpty()
+								? List.of(
+								new FrontendConfigurationResponse.ColumnConfigResponse(
+										"ID",
+										"pid",
+										Map.of("und", "result"),
+										true,
+										true
+								)
+						)
+								: configuredIds
+				);
+
+		List<FrontendConfigurationResponse.VersionContainerResponse> versions = List.of(
+				new FrontendConfigurationResponse.VersionContainerResponse("Backend", getBackendVersion(), null)
+		);
+
+		return new FrontendConfigurationResponse(
+				versions,
+				currency,
+				queryUpload,
+				frontendConfig.manualUrl().orElse(null),
+				frontendConfig.contactEmail().orElse(null),
+				Year.now().minusYears(frontendConfig.observationPeriodYears()).atDay(1)
+		);
+	}
+
+	private String getBackendVersion() {
+		if (buildInfo != null && buildInfo.isResolvable()) {
+			return buildInfo.get().version();
+		}
+		return "0.0.0-SNAPSHOT";
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/FrontendConfigurationResponse.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/FrontendConfigurationResponse.java
new file mode 100644
index 0000000000..c8e21bbb38
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/FrontendConfigurationResponse.java
@@ -0,0 +1,45 @@
+package com.bakdata.conquery.quarkus.config;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Map;
+
+public record FrontendConfigurationResponse(
+		List<VersionContainerResponse> versions,
+		CurrencyConfigResponse currency,
+		IdColumnConfigResponse queryUpload,
+		String manualUrl,
+		String contactEmail,
+		LocalDate observationPeriodStart
+) {
+
+	public record VersionContainerResponse(
+			String name,
+			String version,
+			String error
+	) {
+	}
+
+	public record CurrencyConfigResponse(
+			String unit,
+			String thousandSeparator,
+			String decimalSeparator,
+			int decimalScale
+	) {
+	}
+
+	public record IdColumnConfigResponse(
+			String table,
+			List<ColumnConfigResponse> ids
+	) {
+	}
+
+	public record ColumnConfigResponse(
+			String name,
+			String field,
+			Map<String, String> label,
+			boolean primaryId,
+			boolean print
+	) {
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/FrontendRuntimeConfig.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/FrontendRuntimeConfig.java
new file mode 100644
index 0000000000..0293960ba0
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/FrontendRuntimeConfig.java
@@ -0,0 +1,108 @@
+package com.bakdata.conquery.quarkus.config;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import io.smallrye.config.ConfigMapping;
+import io.smallrye.config.WithDefault;
+
+@ConfigMapping(prefix = "conquery.frontend")
+public interface FrontendRuntimeConfig {
+
+	/**
+	 * Currency formatting options returned by the frontend configuration endpoint.
+	 */
+	Currency currency();
+
+	/**
+	 * Query upload id-column configuration returned by the frontend configuration endpoint.
+	 */
+	QueryUpload queryUpload();
+
+	/**
+	 * Number of years before the current year used to derive the observation period start.
+	 */
+	@WithDefault("6")
+	int observationPeriodYears();
+
+	/**
+	 * Optional manual/help URL shown by the frontend.
+	 */
+	Optional<String> manualUrl();
+
+	/**
+	 * Optional support contact email shown by the frontend.
+	 */
+	Optional<String> contactEmail();
+
+	interface Currency {
+		/**
+		 * Currency unit or symbol.
+		 */
+		@WithDefault("€")
+		String unit();
+
+		/**
+		 * Thousands separator for currency values.
+		 */
+		@WithDefault(".")
+		String thousandSeparator();
+
+		/**
+		 * Decimal separator for currency values.
+		 */
+		@WithDefault(",")
+		String decimalSeparator();
+
+		/**
+		 * Number of fraction digits for currency values.
+		 */
+		@WithDefault("2")
+		int decimalScale();
+	}
+
+	interface QueryUpload {
+		/**
+		 * Logical table name used by the frontend query upload workflow.
+		 */
+		@WithDefault("entities")
+		String table();
+
+		/**
+		 * Entity id columns accepted by the frontend query upload workflow.
+		 */
+		Optional<List<IdColumn>> ids();
+	}
+
+	interface IdColumn {
+		/**
+		 * Display name of the upload id column.
+		 */
+		@WithDefault("ID")
+		String name();
+
+		/**
+		 * Field name used in uploaded rows.
+		 */
+		@WithDefault("pid")
+		String field();
+
+		/**
+		 * Localized labels for this id column.
+		 */
+		Map<String, String> label();
+
+		/**
+		 * Whether this id column is the primary entity id.
+		 */
+		@WithDefault("true")
+		boolean primaryId();
+
+		/**
+		 * Whether this id column should be printed in uploaded query result displays.
+		 */
+		@WithDefault("true")
+		boolean print();
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/JacksonConfiguration.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/JacksonConfiguration.java
new file mode 100644
index 0000000000..a84b5e2bf5
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/JacksonConfiguration.java
@@ -0,0 +1,22 @@
+package com.bakdata.conquery.quarkus.config;
+
+import com.bakdata.conquery.quarkus.models.PolymorphicModelRegistry;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.jsontype.NamedType;
+import io.quarkus.jackson.ObjectMapperCustomizer;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
+
+@Singleton
+public class JacksonConfiguration implements ObjectMapperCustomizer {
+
+	@Inject
+	PolymorphicModelRegistry modelRegistry;
+
+	@Override
+	public void customize(ObjectMapper objectMapper) {
+		objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
+		modelRegistry.allTypes().forEach(type -> objectMapper.registerSubtypes(new NamedType(type.modelType(), type.typeId())));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/SqlRuntimeConfig.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/SqlRuntimeConfig.java
new file mode 100644
index 0000000000..6108800e6d
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/SqlRuntimeConfig.java
@@ -0,0 +1,30 @@
+package com.bakdata.conquery.quarkus.config;
+
+import java.util.Map;
+
+import io.smallrye.config.ConfigMapping;
+import io.smallrye.config.WithDefault;
+
+@ConfigMapping(prefix = "conquery.sql")
+public interface SqlRuntimeConfig {
+
+	/**
+	 * Enables validation and use of SQL datasources for dataset queries.
+	 */
+	@WithDefault("false")
+	boolean enabled();
+
+	/**
+	 * SQL dialect metadata keyed by the corresponding Quarkus named datasource.
+	 */
+	Map<String, SqlDataSource> datasources();
+
+	interface SqlDataSource {
+		SqlDialect dialect();
+	}
+
+	enum SqlDialect {
+		CLICKHOUSE,
+		HANA
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/StorageRuntimeConfig.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/StorageRuntimeConfig.java
new file mode 100644
index 0000000000..7df9ccf791
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/config/StorageRuntimeConfig.java
@@ -0,0 +1,26 @@
+package com.bakdata.conquery.quarkus.config;
+
+import io.smallrye.config.ConfigMapping;
+import io.smallrye.config.WithDefault;
+
+@ConfigMapping(prefix = "conquery.storage")
+public interface StorageRuntimeConfig {
+	/**
+	 * Storage backend used for persistent manager metadata. Dataset definitions are always loaded from metadata folders at startup.
+	 */
+	@WithDefault("IN_MEMORY")
+	String backend();
+
+	/**
+	 * Xodus-specific storage settings used when the XODUS backend is enabled.
+	 */
+	Xodus xodus();
+
+	interface Xodus {
+		/**
+		 * Base directory for Xodus-backed manager metadata.
+		 */
+		@WithDefault("storage/quarkus-meta")
+		String path();
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/ColumnId.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/ColumnId.java
new file mode 100644
index 0000000000..e928aa2036
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/ColumnId.java
@@ -0,0 +1,37 @@
+package com.bakdata.conquery.quarkus.ids;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public record ColumnId(TableId tableId, String name) {
+
+	public ColumnId {
+		if (tableId == null) {
+			throw new IllegalArgumentException("Column id table must not be null.");
+		}
+		name = IdPart.requireValid(name, "Column id name");
+	}
+
+	public DatasetId datasetId() {
+		return tableId.datasetId();
+	}
+
+	@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
+	public static ColumnId parse(String value) {
+		String[] parts = IdPart.split(value, "Column id", 3);
+		if (parts.length != 3) {
+			throw new IllegalArgumentException("Column id must have exactly three parts: " + value);
+		}
+		return new ColumnId(new TableId(DatasetId.parse(parts[0]), parts[1]), parts[2]);
+	}
+
+	public static ColumnId valueOf(String value) {
+		return parse(value);
+	}
+
+	@Override
+	@JsonValue
+	public String toString() {
+		return tableId + "." + name;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/ConceptId.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/ConceptId.java
new file mode 100644
index 0000000000..8897b32b1e
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/ConceptId.java
@@ -0,0 +1,44 @@
+package com.bakdata.conquery.quarkus.ids;
+
+import java.util.Arrays;
+import java.util.List;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public record ConceptId(DatasetId datasetId, List<String> path) {
+
+	public ConceptId {
+		if (datasetId == null) {
+			throw new IllegalArgumentException("Concept id dataset must not be null.");
+		}
+		path = path == null ? List.of() : path.stream()
+											  .map(part -> IdPart.requireValid(part, "Concept id path part"))
+											  .toList();
+	}
+
+	public ConceptId child(String name) {
+		List<String> childPath = new java.util.ArrayList<>(path);
+		childPath.add(name);
+		return new ConceptId(datasetId, childPath);
+	}
+
+	@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
+	public static ConceptId parse(String value) {
+		String[] parts = IdPart.split(value, "Concept id", 1);
+		return new ConceptId(DatasetId.parse(parts[0]), Arrays.stream(parts).skip(1).toList());
+	}
+
+	public static ConceptId valueOf(String value) {
+		return parse(value);
+	}
+
+	@Override
+	@JsonValue
+	public String toString() {
+		if (path.isEmpty()) {
+			return datasetId.toString();
+		}
+		return datasetId + "." + String.join(".", path);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/ConceptSelectId.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/ConceptSelectId.java
new file mode 100644
index 0000000000..f9ecf1996e
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/ConceptSelectId.java
@@ -0,0 +1,38 @@
+package com.bakdata.conquery.quarkus.ids;
+
+import java.util.Arrays;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public record ConceptSelectId(ConceptId conceptId, String name) {
+
+	public ConceptSelectId {
+		if (conceptId == null) {
+			throw new IllegalArgumentException("Concept select id concept must not be null.");
+		}
+		name = IdPart.requireValid(name, "Concept select id name");
+	}
+
+	public DatasetId datasetId() {
+		return conceptId.datasetId();
+	}
+
+	@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
+	public static ConceptSelectId parse(String value) {
+		String[] parts = IdPart.split(value, "Concept select id", 2);
+		String selectName = parts[parts.length - 1];
+		ConceptId conceptId = new ConceptId(DatasetId.parse(parts[0]), Arrays.stream(parts, 1, parts.length - 1).toList());
+		return new ConceptSelectId(conceptId, selectName);
+	}
+
+	public static ConceptSelectId valueOf(String value) {
+		return parse(value);
+	}
+
+	@Override
+	@JsonValue
+	public String toString() {
+		return conceptId + "." + name;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/ConnectorId.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/ConnectorId.java
new file mode 100644
index 0000000000..be20615571
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/ConnectorId.java
@@ -0,0 +1,38 @@
+package com.bakdata.conquery.quarkus.ids;
+
+import java.util.Arrays;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public record ConnectorId(ConceptId conceptId, String name) {
+
+	public ConnectorId {
+		if (conceptId == null) {
+			throw new IllegalArgumentException("Connector id concept must not be null.");
+		}
+		name = IdPart.requireValid(name, "Connector id name");
+	}
+
+	public DatasetId datasetId() {
+		return conceptId.datasetId();
+	}
+
+	@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
+	public static ConnectorId parse(String value) {
+		String[] parts = IdPart.split(value, "Connector id", 2);
+		String connectorName = parts[parts.length - 1];
+		ConceptId conceptId = new ConceptId(DatasetId.parse(parts[0]), Arrays.stream(parts, 1, parts.length - 1).toList());
+		return new ConnectorId(conceptId, connectorName);
+	}
+
+	public static ConnectorId valueOf(String value) {
+		return parse(value);
+	}
+
+	@Override
+	@JsonValue
+	public String toString() {
+		return conceptId + "." + name;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/DatasetId.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/DatasetId.java
new file mode 100644
index 0000000000..5a45f3fa3c
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/DatasetId.java
@@ -0,0 +1,26 @@
+package com.bakdata.conquery.quarkus.ids;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public record DatasetId(String name) {
+
+	public DatasetId {
+		name = IdPart.requireValid(name, "Dataset id");
+	}
+
+	@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
+	public static DatasetId parse(String value) {
+		return new DatasetId(IdPart.split(value, "Dataset id", 1)[0]);
+	}
+
+	public static DatasetId valueOf(String value) {
+		return parse(value);
+	}
+
+	@Override
+	@JsonValue
+	public String toString() {
+		return name;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/FilterId.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/FilterId.java
new file mode 100644
index 0000000000..cdfac77b45
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/FilterId.java
@@ -0,0 +1,39 @@
+package com.bakdata.conquery.quarkus.ids;
+
+import java.util.Arrays;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public record FilterId(ConnectorId connectorId, String name) {
+
+	public FilterId {
+		if (connectorId == null) {
+			throw new IllegalArgumentException("Filter id connector must not be null.");
+		}
+		name = IdPart.requireValid(name, "Filter id name");
+	}
+
+	public DatasetId datasetId() {
+		return connectorId.datasetId();
+	}
+
+	@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
+	public static FilterId parse(String value) {
+		String[] parts = IdPart.split(value, "Filter id", 3);
+		String filterName = parts[parts.length - 1];
+		String connectorName = parts[parts.length - 2];
+		ConceptId conceptId = new ConceptId(DatasetId.parse(parts[0]), Arrays.stream(parts, 1, parts.length - 2).toList());
+		return new FilterId(new ConnectorId(conceptId, connectorName), filterName);
+	}
+
+	public static FilterId valueOf(String value) {
+		return parse(value);
+	}
+
+	@Override
+	@JsonValue
+	public String toString() {
+		return connectorId + "." + name;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/IdPart.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/IdPart.java
new file mode 100644
index 0000000000..d666f20fba
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/IdPart.java
@@ -0,0 +1,41 @@
+package com.bakdata.conquery.quarkus.ids;
+
+import java.util.regex.Pattern;
+
+final class IdPart {
+
+	public static final String PART_PATTERN = "[A-Za-z0-9äöüß_/-]+";
+	private static final Pattern VALID_PART = Pattern.compile(PART_PATTERN);
+
+	private IdPart() {
+	}
+
+	static String requireValid(String value, String label) {
+		if (value == null || value.isBlank()) {
+			throw new IllegalArgumentException(label + " must not be blank.");
+		}
+		String trimmed = value.trim();
+		if (!VALID_PART.matcher(trimmed).matches()) {
+			throw new IllegalArgumentException(label + " must match " + PART_PATTERN + " but was: " + value);
+		}
+		return trimmed;
+	}
+
+	static boolean isValid(String value) {
+		return value != null && VALID_PART.matcher(value.trim()).matches();
+	}
+
+	static String[] split(String value, String label, int minimumParts) {
+		if (value == null || value.isBlank()) {
+			throw new IllegalArgumentException(label + " must not be blank.");
+		}
+		String[] parts = value.trim().split("\\.", -1);
+		if (parts.length < minimumParts) {
+			throw new IllegalArgumentException(label + " must have at least " + minimumParts + " part(s): " + value);
+		}
+		for (int index = 0; index < parts.length; index++) {
+			parts[index] = requireValid(parts[index], label + " part " + index);
+		}
+		return parts;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/IdPartSanitizer.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/IdPartSanitizer.java
new file mode 100644
index 0000000000..207e7c2545
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/IdPartSanitizer.java
@@ -0,0 +1,22 @@
+package com.bakdata.conquery.quarkus.ids;
+
+public final class IdPartSanitizer {
+
+	private IdPartSanitizer() {
+	}
+
+	public static String sanitize(String value, String label) {
+		if (value == null || value.isBlank()) {
+			throw new IllegalArgumentException(label + " must not be blank.");
+		}
+		String sanitized = value.trim()
+								.replace('.', '_')
+								.replaceAll("[^A-Za-z0-9äöü_/-]+", "_")
+								.replaceAll("_+", "_")
+								.replaceAll("^_+|_+$", "");
+		if (sanitized.isBlank() || !IdPart.isValid(sanitized)) {
+			throw new IllegalArgumentException(label + " cannot be sanitized into a valid id part: " + value);
+		}
+		return sanitized;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/SelectId.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/SelectId.java
new file mode 100644
index 0000000000..5b74ade972
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/SelectId.java
@@ -0,0 +1,39 @@
+package com.bakdata.conquery.quarkus.ids;
+
+import java.util.Arrays;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public record SelectId(ConnectorId connectorId, String name) {
+
+	public SelectId {
+		if (connectorId == null) {
+			throw new IllegalArgumentException("Select id connector must not be null.");
+		}
+		name = IdPart.requireValid(name, "Select id name");
+	}
+
+	public DatasetId datasetId() {
+		return connectorId.datasetId();
+	}
+
+	@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
+	public static SelectId parse(String value) {
+		String[] parts = IdPart.split(value, "Select id", 3);
+		String selectName = parts[parts.length - 1];
+		String connectorName = parts[parts.length - 2];
+		ConceptId conceptId = new ConceptId(DatasetId.parse(parts[0]), Arrays.stream(parts, 1, parts.length - 2).toList());
+		return new SelectId(new ConnectorId(conceptId, connectorName), selectName);
+	}
+
+	public static SelectId valueOf(String value) {
+		return parse(value);
+	}
+
+	@Override
+	@JsonValue
+	public String toString() {
+		return connectorId + "." + name;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/StructureNodeId.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/StructureNodeId.java
new file mode 100644
index 0000000000..b83842d278
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/StructureNodeId.java
@@ -0,0 +1,44 @@
+package com.bakdata.conquery.quarkus.ids;
+
+import java.util.Arrays;
+import java.util.List;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public record StructureNodeId(DatasetId datasetId, List<String> path) {
+
+	public StructureNodeId {
+		if (datasetId == null) {
+			throw new IllegalArgumentException("Structure node id dataset must not be null.");
+		}
+		if (path == null || path.isEmpty()) {
+			throw new IllegalArgumentException("Structure node id path must not be empty.");
+		}
+		path = path.stream()
+				.map(part -> IdPart.requireValid(part, "Structure node id path part"))
+				.toList();
+	}
+
+	public StructureNodeId child(String name) {
+		List<String> childPath = new java.util.ArrayList<>(path);
+		childPath.add(name);
+		return new StructureNodeId(datasetId, childPath);
+	}
+
+	@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
+	public static StructureNodeId parse(String value) {
+		String[] parts = IdPart.split(value, "Structure node id", 2);
+		return new StructureNodeId(DatasetId.parse(parts[0]), Arrays.stream(parts).skip(1).toList());
+	}
+
+	public static StructureNodeId valueOf(String value) {
+		return parse(value);
+	}
+
+	@Override
+	@JsonValue
+	public String toString() {
+		return datasetId + "." + String.join(".", path);
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/TableId.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/TableId.java
new file mode 100644
index 0000000000..5cc8efed4b
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/TableId.java
@@ -0,0 +1,33 @@
+package com.bakdata.conquery.quarkus.ids;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public record TableId(DatasetId datasetId, String name) {
+
+	public TableId {
+		if (datasetId == null) {
+			throw new IllegalArgumentException("Table id dataset must not be null.");
+		}
+		name = IdPart.requireValid(name, "Table id name");
+	}
+
+	@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
+	public static TableId parse(String value) {
+		String[] parts = IdPart.split(value, "Table id", 2);
+		if (parts.length != 2) {
+			throw new IllegalArgumentException("Table id must have exactly two parts: " + value);
+		}
+		return new TableId(DatasetId.parse(parts[0]), parts[1]);
+	}
+
+	public static TableId valueOf(String value) {
+		return parse(value);
+	}
+
+	@Override
+	@JsonValue
+	public String toString() {
+		return datasetId + "." + name;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/ValidityDateId.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/ValidityDateId.java
new file mode 100644
index 0000000000..a7512d1be8
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/ids/ValidityDateId.java
@@ -0,0 +1,39 @@
+package com.bakdata.conquery.quarkus.ids;
+
+import java.util.Arrays;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public record ValidityDateId(ConnectorId connectorId, String name) {
+
+	public ValidityDateId {
+		if (connectorId == null) {
+			throw new IllegalArgumentException("Validity date id connector must not be null.");
+		}
+		name = IdPart.requireValid(name, "Validity date id name");
+	}
+
+	public DatasetId datasetId() {
+		return connectorId.datasetId();
+	}
+
+	@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
+	public static ValidityDateId parse(String value) {
+		String[] parts = IdPart.split(value, "Validity date id", 3);
+		String validityDateName = parts[parts.length - 1];
+		String connectorName = parts[parts.length - 2];
+		ConceptId conceptId = new ConceptId(DatasetId.parse(parts[0]), Arrays.stream(parts, 1, parts.length - 2).toList());
+		return new ValidityDateId(new ConnectorId(conceptId, connectorName), validityDateName);
+	}
+
+	public static ValidityDateId valueOf(String value) {
+		return parse(value);
+	}
+
+	@Override
+	@JsonValue
+	public String toString() {
+		return connectorId + "." + name;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelBase.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelBase.java
new file mode 100644
index 0000000000..7800850ba8
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelBase.java
@@ -0,0 +1,17 @@
+package com.bakdata.conquery.quarkus.models;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface PolymorphicModelBase {
+
+	String discriminator() default "type";
+
+	String schemaName();
+
+	String description() default "";
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelRegistry.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelRegistry.java
new file mode 100644
index 0000000000..2d199b33c5
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelRegistry.java
@@ -0,0 +1,107 @@
+package com.bakdata.conquery.quarkus.models;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import jakarta.annotation.PostConstruct;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.inject.Instance;
+import jakarta.inject.Inject;
+
+@ApplicationScoped
+public class PolymorphicModelRegistry {
+
+	@Inject
+	Instance<PolymorphicModelTypeProvider<?, ?>> providers;
+	@Inject
+	Instance<com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelTypeProvider<?, ?>> pluginProviders;
+
+	private Map<Class<?>, Map<String, PolymorphicModelType<?, ?>>> typesByBase = Map.of();
+
+	@PostConstruct
+	void init() {
+		Map<Class<?>, Map<String, PolymorphicModelType<?, ?>>> index = new LinkedHashMap<>();
+		for (PolymorphicModelTypeProvider<?, ?> provider : providers) {
+			register(index, provider);
+		}
+		for (com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelTypeProvider<?, ?> provider : pluginProviders) {
+			register(index, provider);
+		}
+		Map<Class<?>, Map<String, PolymorphicModelType<?, ?>>> immutableIndex = new LinkedHashMap<>();
+		index.forEach((base, types) -> immutableIndex.put(base, Map.copyOf(types)));
+		typesByBase = Map.copyOf(immutableIndex);
+	}
+
+	public List<PolymorphicModelType<?, ?>> allTypes() {
+		return typesByBase.values().stream()
+				.flatMap(types -> types.values().stream())
+				.sorted(Comparator.comparing(type -> type.baseType().getName() + ":" + type.typeId()))
+				.toList();
+	}
+
+	public <B> List<PolymorphicModelType<B, ? extends B>> types(Class<B> baseType) {
+		List<PolymorphicModelType<B, ? extends B>> result = new ArrayList<>();
+		for (PolymorphicModelType<?, ?> type : typesByBase.getOrDefault(baseType, Map.of()).values()) {
+			result.add(cast(type));
+		}
+		result.sort(Comparator.comparing(PolymorphicModelType::typeId));
+		return List.copyOf(result);
+	}
+
+	public <B> Optional<PolymorphicModelType<B, ? extends B>> find(Class<B> baseType, String typeId) {
+		return Optional.ofNullable(typesByBase.getOrDefault(baseType, Map.of()).get(typeId)).map(this::cast);
+	}
+
+	private void register(Map<Class<?>, Map<String, PolymorphicModelType<?, ?>>> index, PolymorphicModelTypeProvider<?, ?> provider) {
+		register(index, provider.baseType(), provider.modelType(), provider.typeId(), descriptor(provider));
+	}
+
+	private void register(
+			Map<Class<?>, Map<String, PolymorphicModelType<?, ?>>> index,
+			com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelTypeProvider<?, ?> provider
+	) {
+		register(index, provider.baseType(), provider.modelType(), provider.typeId(), descriptor(provider));
+	}
+
+	private void register(
+			Map<Class<?>, Map<String, PolymorphicModelType<?, ?>>> index,
+			Class<?> baseType,
+			Class<?> modelType,
+			String typeId,
+			PolymorphicModelType<?, ?> descriptor
+	) {
+		if (typeId == null || typeId.isBlank()) {
+			throw new IllegalStateException("Polymorphic model type id must not be blank for " + modelType.getName());
+		}
+		if (!baseType.isAssignableFrom(modelType)) {
+			throw new IllegalStateException("Polymorphic model " + modelType.getName() + " does not implement " + baseType.getName());
+		}
+		if (baseType.getAnnotation(PolymorphicModelBase.class) == null
+				&& baseType.getAnnotation(com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelBase.class) == null) {
+			throw new IllegalStateException("Polymorphic model base " + baseType.getName() + " must be annotated with @PolymorphicModelBase");
+		}
+		PolymorphicModelType<?, ?> previous = index.computeIfAbsent(baseType, ignored -> new LinkedHashMap<>()).put(typeId, descriptor);
+		if (previous != null) {
+			throw new IllegalStateException("Duplicate polymorphic model type '" + typeId + "' for " + baseType.getName() + ": " + previous.modelType().getName() + " and " + modelType.getName());
+		}
+	}
+
+	private <B, T extends B> PolymorphicModelType<B, T> descriptor(PolymorphicModelTypeProvider<B, T> provider) {
+		return new PolymorphicModelType<>(provider.baseType(), provider.typeId(), provider.modelType());
+	}
+
+	private <B, T extends B> PolymorphicModelType<B, T> descriptor(
+			com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelTypeProvider<B, T> provider
+	) {
+		return new PolymorphicModelType<>(provider.baseType(), provider.typeId(), provider.modelType());
+	}
+
+	@SuppressWarnings("unchecked")
+	private <B> PolymorphicModelType<B, ? extends B> cast(PolymorphicModelType<?, ?> type) {
+		return (PolymorphicModelType<B, ? extends B>) type;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelSubtype.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelSubtype.java
new file mode 100644
index 0000000000..9bdd891a5d
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelSubtype.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.quarkus.models;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Declares the serialized identity of a concrete polymorphic model.
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface PolymorphicModelSubtype {
+
+	Class<?> base();
+
+	String id();
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelType.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelType.java
new file mode 100644
index 0000000000..19bdf035e1
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelType.java
@@ -0,0 +1,8 @@
+package com.bakdata.conquery.quarkus.models;
+
+public record PolymorphicModelType<B, T extends B>(
+		Class<B> baseType,
+		String typeId,
+		Class<T> modelType
+) {
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelTypeProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelTypeProvider.java
new file mode 100644
index 0000000000..44cc26b77f
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelTypeProvider.java
@@ -0,0 +1,24 @@
+package com.bakdata.conquery.quarkus.models;
+
+public interface PolymorphicModelTypeProvider<B, T extends B> {
+
+	Class<T> modelType();
+
+	@SuppressWarnings("unchecked")
+	default Class<B> baseType() {
+		return (Class<B>) subtype().base();
+	}
+
+	default String typeId() {
+		return subtype().id();
+	}
+
+	private PolymorphicModelSubtype subtype() {
+		PolymorphicModelSubtype subtype = modelType().getAnnotation(PolymorphicModelSubtype.class);
+		if (subtype == null) {
+			throw new IllegalStateException("Polymorphic model " + modelType().getName()
+					+ " must be annotated with @PolymorphicModelSubtype");
+		}
+		return subtype;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelsOpenApiFilter.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelsOpenApiFilter.java
new file mode 100644
index 0000000000..8365f5ed8c
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/models/PolymorphicModelsOpenApiFilter.java
@@ -0,0 +1,245 @@
+package com.bakdata.conquery.quarkus.models;
+
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.RecordComponent;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+import io.quarkus.arc.Arc;
+import io.quarkus.smallrye.openapi.OpenApiFilter;
+import org.eclipse.microprofile.openapi.OASFactory;
+import org.eclipse.microprofile.openapi.OASFilter;
+import org.eclipse.microprofile.openapi.models.Components;
+import org.eclipse.microprofile.openapi.models.OpenAPI;
+import org.eclipse.microprofile.openapi.models.media.Discriminator;
+import org.eclipse.microprofile.openapi.models.media.Schema;
+
+/**
+ * Aligns the generated OpenAPI document with the runtime Jackson model.
+ * <p>
+ * Vanilla SmallRye OpenAPI generation cannot fully describe the model for two reasons:
+ * <ul>
+ *     <li>Polymorphic implementations are registered dynamically through CDI providers. The static OpenAPI scan does
+ *     not know which implementations belong to a base type, so it cannot build the corresponding {@code oneOf} and
+ *     discriminator mappings.</li>
+ *     <li>Some value objects, notably IDs, are structured records in Java but use a delegating {@code @JsonCreator}
+ *     and {@code @JsonValue} to deserialize and serialize as scalars. SmallRye otherwise exposes their internal record
+ *     components instead of their JSON representation.</li>
+ * </ul>
+ * This filter projects the runtime polymorphic registry into OpenAPI and replaces affected component schemas with the
+ * scalar type used by Jackson. As a result, generated clients see the same shapes that the API actually accepts and
+ * returns.
+ */
+@OpenApiFilter(OpenApiFilter.RunStage.RUN)
+public class PolymorphicModelsOpenApiFilter implements OASFilter {
+
+	@Override
+	public void filterOpenAPI(OpenAPI openAPI) {
+		PolymorphicModelRegistry registry = Arc.container().instance(PolymorphicModelRegistry.class).get();
+		Components components = openAPI.getComponents();
+		if (components == null) {
+			components = OASFactory.createComponents();
+			openAPI.setComponents(components);
+		}
+
+		Map<Class<?>, List<PolymorphicModelType<?, ?>>> byBase = new LinkedHashMap<>();
+		registry.allTypes().forEach(type -> byBase.computeIfAbsent(type.baseType(), ignored -> new ArrayList<>()).add(type));
+		for (Map.Entry<Class<?>, List<PolymorphicModelType<?, ?>>> family : byBase.entrySet()) {
+			addFamilySchema(components, family.getKey(), family.getValue());
+		}
+		replaceJacksonScalarSchemas(components, registry.allTypes());
+	}
+
+	private void replaceJacksonScalarSchemas(Components components, Collection<PolymorphicModelType<?, ?>> types) {
+		Set<Class<?>> visited = new HashSet<>();
+		for (PolymorphicModelType<?, ?> type : types) {
+			visitReferencedTypes(components, type.modelType(), visited);
+		}
+	}
+
+	private void visitReferencedTypes(Components components, Type type, Set<Class<?>> visited) {
+		if (type instanceof ParameterizedType parameterizedType) {
+			visitReferencedTypes(components, parameterizedType.getRawType(), visited);
+			for (Type argument : parameterizedType.getActualTypeArguments()) {
+				visitReferencedTypes(components, argument, visited);
+			}
+			return;
+		}
+		if (!(type instanceof Class<?> modelType) || modelType.isPrimitive() || modelType.isArray() || !visited.add(modelType)) {
+			return;
+		}
+
+		Optional<Class<?>> scalarType = jacksonScalarType(modelType);
+		if (scalarType.isPresent()) {
+			replaceComponentSchema(components, modelType, scalarType.get());
+			return;
+		}
+		if (!modelType.getPackageName().startsWith("com.bakdata.conquery")) {
+			return;
+		}
+
+		for (RecordComponent component : modelType.getRecordComponents() == null ? new RecordComponent[0] : modelType.getRecordComponents()) {
+			visitReferencedTypes(components, component.getGenericType(), visited);
+		}
+		for (Field field : modelType.getDeclaredFields()) {
+			if (!field.isSynthetic() && !Modifier.isStatic(field.getModifiers())) {
+				visitReferencedTypes(components, field.getGenericType(), visited);
+			}
+		}
+		Class<?> superType = modelType.getSuperclass();
+		if (superType != null) {
+			visitReferencedTypes(components, superType, visited);
+		}
+	}
+
+	private Optional<Class<?>> jacksonScalarType(Class<?> modelType) {
+		Optional<Class<?>> creatorType = delegatingCreatorType(modelType);
+		Optional<Class<?>> jsonValueType = jsonValueType(modelType);
+		if (creatorType.isEmpty() || jsonValueType.isEmpty()) {
+			return Optional.empty();
+		}
+		if (!creatorType.get().equals(jsonValueType.get())) {
+			throw new IllegalStateException("Jackson scalar model " + modelType.getName()
+					+ " uses incompatible @JsonCreator and @JsonValue types: "
+					+ creatorType.get().getName() + " and " + jsonValueType.get().getName());
+		}
+		return creatorType;
+	}
+
+	private Optional<Class<?>> delegatingCreatorType(Class<?> modelType) {
+		for (Method method : modelType.getDeclaredMethods()) {
+			JsonCreator creator = method.getAnnotation(JsonCreator.class);
+			if (isDelegatingCreator(creator, method.getParameterCount())) {
+				return Optional.of(method.getParameterTypes()[0]);
+			}
+		}
+		for (Constructor<?> constructor : modelType.getDeclaredConstructors()) {
+			JsonCreator creator = constructor.getAnnotation(JsonCreator.class);
+			if (isDelegatingCreator(creator, constructor.getParameterCount())) {
+				return Optional.of(constructor.getParameterTypes()[0]);
+			}
+		}
+		return Optional.empty();
+	}
+
+	private boolean isDelegatingCreator(JsonCreator creator, int parameterCount) {
+		return creator != null && creator.mode() == JsonCreator.Mode.DELEGATING && parameterCount == 1;
+	}
+
+	private Optional<Class<?>> jsonValueType(Class<?> modelType) {
+		for (Method method : modelType.getDeclaredMethods()) {
+			if (isJsonValue(method)) {
+				return Optional.of(method.getReturnType());
+			}
+		}
+		for (Field field : modelType.getDeclaredFields()) {
+			if (isJsonValue(field)) {
+				return Optional.of(field.getType());
+			}
+		}
+		return Optional.empty();
+	}
+
+	private boolean isJsonValue(AnnotatedElement element) {
+		JsonValue annotation = element.getAnnotation(JsonValue.class);
+		return annotation != null && annotation.value();
+	}
+
+	private void replaceComponentSchema(Components components, Class<?> modelType, Class<?> scalarType) {
+		if (components.getSchemas() == null) {
+			return;
+		}
+		String name = schemaName(modelType);
+		Schema existing = components.getSchemas().get(name);
+		if (existing == null) {
+			return;
+		}
+		Schema replacement = OASFactory.createSchema().addType(openApiScalarType(modelType, scalarType));
+		if (existing.getDescription() != null) {
+			replacement.description(existing.getDescription());
+		}
+		components.addSchema(name, replacement);
+	}
+
+	private Schema.SchemaType openApiScalarType(Class<?> modelType, Class<?> scalarType) {
+		if (scalarType == String.class || scalarType == char.class || scalarType == Character.class) {
+			return Schema.SchemaType.STRING;
+		}
+		if (scalarType == boolean.class || scalarType == Boolean.class) {
+			return Schema.SchemaType.BOOLEAN;
+		}
+		if (scalarType == byte.class || scalarType == Byte.class
+				|| scalarType == short.class || scalarType == Short.class
+				|| scalarType == int.class || scalarType == Integer.class
+				|| scalarType == long.class || scalarType == Long.class) {
+			return Schema.SchemaType.INTEGER;
+		}
+		if (Number.class.isAssignableFrom(scalarType) || scalarType == float.class || scalarType == double.class) {
+			return Schema.SchemaType.NUMBER;
+		}
+		throw new IllegalStateException("Unsupported @JsonCreator scalar type " + scalarType.getName() + " on " + modelType.getName());
+	}
+
+	private void addFamilySchema(Components components, Class<?> baseType, List<PolymorphicModelType<?, ?>> types) {
+		FamilySchema family = familySchema(baseType);
+		Discriminator discriminator = OASFactory.createDiscriminator().propertyName(family.discriminator());
+		List<Schema> alternatives = new ArrayList<>();
+		for (PolymorphicModelType<?, ?> type : types) {
+			String schemaName = schemaName(type.modelType());
+			Schema concreteSchema = components.getSchemas() == null ? null : components.getSchemas().get(schemaName);
+			if (concreteSchema == null) {
+				throw new IllegalStateException("No generated OpenAPI schema found for registered polymorphic model " + type.modelType().getName() + ". Annotate and index the model class so SmallRye OpenAPI can discover it.");
+			}
+			concreteSchema.addProperty(family.discriminator(), OASFactory.createSchema()
+					.addType(Schema.SchemaType.STRING)
+					.constValue(type.typeId()));
+			concreteSchema.addRequired(family.discriminator());
+			String reference = "#/components/schemas/" + schemaName;
+			discriminator.addMapping(type.typeId(), reference);
+			alternatives.add(OASFactory.createSchema().ref(reference));
+		}
+		Schema familySchema = OASFactory.createSchema()
+				.description(family.description())
+				.discriminator(discriminator)
+				.oneOf(List.copyOf(alternatives));
+		components.addSchema(family.schemaName(), familySchema);
+	}
+
+	private FamilySchema familySchema(Class<?> baseType) {
+		PolymorphicModelBase internal = baseType.getAnnotation(PolymorphicModelBase.class);
+		if (internal != null) {
+			return new FamilySchema(internal.discriminator(), internal.schemaName(), internal.description());
+		}
+		com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelBase plugin =
+				baseType.getAnnotation(com.bakdata.conquery.quarkus.plugin.api.models.PolymorphicModelBase.class);
+		if (plugin != null) {
+			return new FamilySchema(plugin.discriminator(), plugin.schemaName(), plugin.description());
+		}
+		throw new IllegalStateException("Polymorphic model base " + baseType.getName() + " is not annotated");
+	}
+
+	private record FamilySchema(String discriminator, String schemaName, String description) {
+	}
+
+	private String schemaName(Class<?> modelType) {
+		org.eclipse.microprofile.openapi.annotations.media.Schema annotation = modelType.getAnnotation(org.eclipse.microprofile.openapi.annotations.media.Schema.class);
+		if (annotation != null && !annotation.name().isBlank()) {
+			return annotation.name();
+		}
+		return modelType.getSimpleName();
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/services/DatasetService.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/services/DatasetService.java
new file mode 100644
index 0000000000..1c79e85b25
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/services/DatasetService.java
@@ -0,0 +1,107 @@
+package com.bakdata.conquery.quarkus.services;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.config.StorageRuntimeConfig;
+import com.bakdata.conquery.quarkus.ids.ConceptId;
+import com.bakdata.conquery.quarkus.ids.DatasetId;
+import com.bakdata.conquery.quarkus.ids.TableId;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import com.bakdata.conquery.quarkus.storage.NamespaceStorage;
+import com.bakdata.conquery.quarkus.storage.NamespaceStorageRegistry;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import jakarta.ws.rs.NotFoundException;
+import org.jboss.resteasy.reactive.common.NotImplementedYet;
+
+@ApplicationScoped
+public class DatasetService {
+
+	@Inject
+	NamespaceStorageRegistry namespaceStorageRegistry;
+
+	@Inject
+	@SuppressWarnings("unused")
+	StorageRuntimeConfig storageRuntimeConfig;
+
+	public List<DatasetCatalogRepository.DatasetRecord> listDatasets() {
+		return namespaceStorageRegistry.listDatasets();
+	}
+
+	public DatasetCatalogRepository.DatasetRecord requireDataset(String datasetId) {
+		return requireDataset(DatasetId.parse(datasetId));
+	}
+
+	public DatasetCatalogRepository.DatasetRecord requireDataset(DatasetId datasetId) {
+		return requireNamespace(datasetId).dataset();
+	}
+
+	public DatasetCatalogRepository.Concept requireConcept(String conceptId) {
+		return requireConcept(ConceptId.parse(conceptId));
+	}
+
+	public DatasetCatalogRepository.Concept requireConcept(ConceptId conceptId) {
+		NamespaceStorage namespace = requireNamespace(conceptId.datasetId());
+		return namespace.findConcept(conceptId).orElseThrow(() -> new NotFoundException("Unknown concept: " + conceptId));
+	}
+
+	public List<DatasetCatalogRepository.Concept> listRootConceptsForDataset(String datasetId) {
+		return listRootConceptsForDataset(DatasetId.parse(datasetId));
+	}
+
+	public List<DatasetCatalogRepository.Concept> listRootConceptsForDataset(DatasetId datasetId) {
+		return requireNamespace(datasetId).listConcepts();
+	}
+
+	public List<DatasetCatalogRepository.StructureNode> listStructureNodesForDataset(String datasetId) {
+		return requireNamespace(DatasetId.parse(datasetId)).listStructureNodes();
+	}
+
+	public List<DatasetCatalogRepository.TableRecord> listTablesForDataset(String datasetId) {
+		return listTablesForDataset(DatasetId.parse(datasetId));
+	}
+
+	public List<DatasetCatalogRepository.TableRecord> listTablesForDataset(DatasetId datasetId) {
+		return requireNamespace(datasetId).listTables();
+	}
+
+	public DatasetCatalogRepository.TableRecord requireTable(String tableId) {
+		return requireTable(TableId.parse(tableId));
+	}
+
+	public DatasetCatalogRepository.TableRecord requireTable(TableId tableId) {
+		NamespaceStorage namespace = requireNamespace(tableId.datasetId());
+		return namespace.findTable(tableId).orElseThrow(() -> new NotFoundException("Unknown table: " + tableId));
+	}
+
+	public ConceptCodeResolution resolveConceptCodes(String rootConceptId, List<String> codes) {
+		ConceptId parsedRootConceptId = ConceptId.parse(rootConceptId);
+		DatasetCatalogRepository.Concept rootConcept = requireConcept(parsedRootConceptId);
+		NamespaceStorage namespace = requireNamespace(parsedRootConceptId.datasetId());
+
+		// TODO implement with updated concept model
+		throw new NotImplementedYet();
+
+//		List<String> resolvedInOrder = codes.stream()
+//										.map(this::normalizeCode)
+//										.map(lookupByCode::get)
+//										.filter(java.util.Objects::nonNull)
+//										.toList();
+//		List<String> unknownCodes = codes.stream()
+//									 .filter(code -> !lookupByCode.containsKey(normalizeCode(code)))
+//									 .toList();
+//
+//		return new ConceptCodeResolution(List.copyOf(new LinkedHashSet<>(resolvedInOrder)), unknownCodes);
+	}
+
+	private NamespaceStorage requireNamespace(DatasetId datasetId) {
+		return namespaceStorageRegistry.findNamespace(datasetId)
+									   .orElseThrow(() -> new NotFoundException("Unknown dataset: " + datasetId));
+	}
+
+	public record ConceptCodeResolution(
+			List<String> resolvedConcepts,
+			List<String> unknownCodes
+	) {
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/services/EntityQueryService.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/services/EntityQueryService.java
new file mode 100644
index 0000000000..2e0a81bc96
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/services/EntityQueryService.java
@@ -0,0 +1,90 @@
+package com.bakdata.conquery.quarkus.services;
+
+import java.util.List;
+import java.util.Map;
+
+import com.bakdata.conquery.quarkus.api.QuerySubmissionPayload;
+import com.bakdata.conquery.quarkus.concepts.filters.values.FilterValue;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.ws.rs.WebApplicationException;
+import jakarta.ws.rs.core.Response;
+
+@ApplicationScoped
+public class EntityQueryService {
+
+	// TODO(quarkus-migration): Implement entity queries against dataset data. The records below only preserve the API models.
+	public EntityHistoryResponse getEntityHistory(EntityHistoryRequest request) {
+		throw notImplemented();
+	}
+
+	public List<Map<String, String>> resolveEntities(List<FilterValue> filters) {
+		throw notImplemented();
+	}
+
+	private WebApplicationException notImplemented() {
+		return new WebApplicationException("Entity queries are not implemented yet.", Response.Status.NOT_IMPLEMENTED);
+	}
+
+	public record EntityHistoryRequest(
+			String idKind,
+			String entityId,
+			QuerySubmissionPayload.DateRangePayload time,
+			List<String> sources
+	) {
+	}
+
+	public record EntityHistoryResponse(
+			List<ResultUrlWithLabelResponse> resultUrls,
+			List<ColumnDescriptionResponse> columnDescriptions,
+			List<EntityInfoResponse> infos,
+			List<TimeStratifiedInfoResponse> timeStratifiedInfos
+	) {
+	}
+
+	public record ResultUrlWithLabelResponse(
+			String label,
+			String url
+	) {
+	}
+
+	public record ColumnDescriptionResponse(
+			String label,
+			String description,
+			String type,
+			List<Map<String, String>> semantics,
+			String defaultLabel,
+			String selectId,
+			String userConceptLabel
+	) {
+	}
+
+	public record EntityInfoResponse(
+			String label,
+			String value,
+			String type,
+			List<Map<String, String>> semantics
+	) {
+	}
+
+	public record TimeStratifiedInfoResponse(
+			String label,
+			String description,
+			Map<String, Object> totals,
+			List<ColumnDescriptionResponse> columns,
+			List<TimeStratifiedInfoYearResponse> years
+	) {
+	}
+
+	public record TimeStratifiedInfoYearResponse(
+			int year,
+			Map<String, Object> values,
+			List<TimeStratifiedInfoQuarterResponse> quarters
+	) {
+	}
+
+	public record TimeStratifiedInfoQuarterResponse(
+			int quarter,
+			Map<String, String> values
+	) {
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/services/FormConfigService.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/services/FormConfigService.java
new file mode 100644
index 0000000000..fb06edd2d7
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/services/FormConfigService.java
@@ -0,0 +1,123 @@
+package com.bakdata.conquery.quarkus.services;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+import com.bakdata.conquery.quarkus.api.DatasetFormConfigResource;
+import com.bakdata.conquery.quarkus.api.FormConfigResource;
+import com.bakdata.conquery.quarkus.storage.meta.ManagerMetaStorage;
+import com.bakdata.conquery.quarkus.storage.model.StoredFormConfig;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import jakarta.ws.rs.NotFoundException;
+
+@ApplicationScoped
+public class FormConfigService {
+
+	@Inject
+	ManagerMetaStorage metaStorage;
+
+	public DatasetFormConfigResource.PostFormConfigResponse create(
+			String datasetId,
+			DatasetFormConfigResource.FormConfigCreatePayload payload,
+			String ownerName
+	) {
+		String id = datasetId + ":" + payload.formType + ":" + UUID.randomUUID();
+		StoredFormConfig stored = new StoredFormConfig(
+				id,
+				datasetId,
+				payload.formType,
+				payload.label,
+				List.copyOf(payload.tags),
+				ownerName,
+				Instant.now(),
+				false,
+				List.of(),
+				payload.values
+		);
+		metaStorage.formConfigs().save(stored);
+		return new DatasetFormConfigResource.PostFormConfigResponse(id);
+	}
+
+	public List<DatasetFormConfigResource.FormConfigOverviewResponse> list(
+			String datasetId,
+			Set<String> requestedFormTypes,
+			String requester
+	) {
+		return metaStorage.formConfigs().listByDataset(datasetId).stream()
+						  .filter(config -> requestedFormTypes == null
+								  || requestedFormTypes.isEmpty()
+								  || requestedFormTypes.contains(config.getFormType()))
+						  .sorted((left, right) -> right.getCreatedAt().compareTo(left.getCreatedAt()))
+						  .map(config -> toOverview(config, requester))
+						  .toList();
+	}
+
+	public FormConfigResource.FormConfigFullResponse get(String formConfigId, String requester) {
+		return toFull(require(formConfigId), requester);
+	}
+
+	public FormConfigResource.FormConfigFullResponse patch(
+			String formConfigId,
+			FormConfigResource.FormConfigPatchPayload payload,
+			String requester
+	) {
+		StoredFormConfig config = require(formConfigId);
+		if (payload.label != null) {
+			config.setLabel(payload.label);
+		}
+		if (payload.tags != null) {
+			config.setTags(List.copyOf(payload.tags));
+		}
+		if (payload.groups != null) {
+			config.setGroups(List.copyOf(payload.groups));
+		}
+		if (payload.values != null) {
+			config.setValues(payload.values);
+		}
+		metaStorage.formConfigs().save(config);
+		return toFull(config, requester);
+	}
+
+	public void delete(String formConfigId) {
+		if (!metaStorage.formConfigs().deleteById(formConfigId)) {
+			throw new NotFoundException("Unknown form-config: " + formConfigId);
+		}
+	}
+
+	private DatasetFormConfigResource.FormConfigOverviewResponse toOverview(StoredFormConfig config, String requester) {
+		return new DatasetFormConfigResource.FormConfigOverviewResponse(
+				config.getId(),
+				config.getFormType(),
+				config.getLabel(),
+				config.getTags(),
+				config.getOwnerName(),
+				config.getCreatedAt().toString(),
+				config.getOwnerName().equals(requester),
+				!config.getGroups().isEmpty(),
+				config.isSystem()
+		);
+	}
+
+	private FormConfigResource.FormConfigFullResponse toFull(StoredFormConfig config, String requester) {
+		return new FormConfigResource.FormConfigFullResponse(
+				config.getId(),
+				config.getFormType(),
+				config.getLabel(),
+				config.getTags(),
+				config.getOwnerName(),
+				config.getCreatedAt().toString(),
+				config.getOwnerName().equals(requester),
+				!config.getGroups().isEmpty(),
+				config.isSystem(),
+				config.getGroups(),
+				config.getValues()
+		);
+	}
+
+	private StoredFormConfig require(String formConfigId) {
+		return metaStorage.formConfigs().findById(formConfigId).orElseThrow(() -> new NotFoundException("Unknown form-config: " + formConfigId));
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/services/QueryStateService.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/services/QueryStateService.java
new file mode 100644
index 0000000000..daa11b9b9d
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/services/QueryStateService.java
@@ -0,0 +1,287 @@
+package com.bakdata.conquery.quarkus.services;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
+import java.util.UUID;
+
+import com.bakdata.conquery.quarkus.api.DatasetsResource;
+import com.bakdata.conquery.quarkus.api.QueryResource;
+import com.bakdata.conquery.quarkus.api.QuerySubmissionPayload;
+import com.bakdata.conquery.quarkus.storage.meta.ManagerMetaStorage;
+import com.bakdata.conquery.quarkus.storage.model.StoredQuery;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import jakarta.ws.rs.NotFoundException;
+
+@ApplicationScoped
+public class QueryStateService {
+
+	@Inject
+	ManagerMetaStorage metaStorage;
+
+	public DatasetsResource.StartQueryResponse createQuery(String datasetId, QuerySubmissionPayload payload, String ownerName) {
+		String queryId = UUID.randomUUID().toString();
+		Instant createdAt = Instant.now();
+		QueryResource.QueryType queryType = resolveQueryType(payload);
+		QueryResource.QueryDefinition definition = toQueryDefinition(payload, queryType);
+
+		StoredQuery stored = new StoredQuery(
+				queryId,
+				datasetId,
+				labelFor(queryId),
+				createdAt,
+				ownerName,
+				definition,
+				extractSecondaryId(payload),
+				containsDates(extractRoot(payload)),
+				QueryResource.QueryStatus.NEW,
+				List.of(),
+				false,
+				List.of()
+		);
+
+		metaStorage.queries().save(stored);
+		return new DatasetsResource.StartQueryResponse(queryId);
+	}
+
+	public List<DatasetsResource.QuerySummaryResponse> getDatasetQueries(String datasetId) {
+		return metaStorage.queries().listByDataset(datasetId).stream()
+						 .sorted(Comparator.comparing(StoredQuery::getCreatedAt).reversed())
+						 .map(this::toSummaryResponse)
+						 .toList();
+	}
+
+	public QueryResource.QueryResponse getQuery(String queryId) {
+		StoredQuery query = requireQuery(queryId);
+		return toQueryResponse(query);
+	}
+
+	public void cancelQuery(String queryId) {
+		StoredQuery query = requireQuery(queryId);
+		if (query.getStatus() == QueryResource.QueryStatus.NEW || query.getStatus() == QueryResource.QueryStatus.RUNNING) {
+			query.setStatus(QueryResource.QueryStatus.CANCELED);
+		}
+	}
+
+	public void patchQuery(String queryId, QueryPatch patch) {
+		StoredQuery query = requireQuery(queryId);
+		if (patch.label() != null && !patch.label().isBlank()) {
+			query.setLabel(patch.label());
+		}
+		if (patch.tags() != null) {
+			query.setTags(List.copyOf(patch.tags()));
+		}
+		if (patch.shared() != null) {
+			query.setShared(patch.shared());
+		}
+		if (patch.groups() != null) {
+			query.setGroups(List.copyOf(patch.groups()));
+		}
+	}
+
+	public void deleteQuery(String queryId) {
+		if (!metaStorage.queries().deleteById(queryId)) {
+			throw new NotFoundException("Unknown query: " + queryId);
+		}
+	}
+
+	private DatasetsResource.QuerySummaryResponse toSummaryResponse(StoredQuery query) {
+		return new DatasetsResource.QuerySummaryResponse(
+				query.getId(),
+				query.getLabel(),
+				query.getStatus() == QueryResource.QueryStatus.DONE ? 0L : null,
+				query.getCreatedAt().toString(),
+				query.getTags(),
+				true,
+				query.getOwnerName(),
+				false,
+				List.of(),
+				query.isShared(),
+				false,
+				query.getDefinition().type.name(),
+				query.getSecondaryId(),
+				query.isContainsDates()
+		);
+	}
+
+	private QueryResource.QueryResponse toQueryResponse(StoredQuery query) {
+		return switch (query.getStatus()) {
+			case RUNNING -> new QueryResource.RunningQueryResponse(
+					query.getId(),
+					query.getLabel(),
+					query.getCreatedAt().toString(),
+					true,
+					query.isShared(),
+					false,
+					query.getTags(),
+					query.getDefinition(),
+					query.getSecondaryId(),
+					query.getOwnerName(),
+					query.getGroups(),
+					false,
+					List.of(),
+					null
+			);
+			case DONE -> new QueryResource.DoneQueryResponse(
+					query.getId(),
+					query.getLabel(),
+					query.getCreatedAt().toString(),
+					true,
+					query.isShared(),
+					false,
+					query.getTags(),
+					query.getDefinition(),
+					query.getSecondaryId(),
+					query.getOwnerName(),
+					query.getGroups(),
+					false,
+					List.of(),
+					0L,
+					List.of(),
+					query.getDefinition().type,
+					0L,
+					query.isContainsDates()
+			);
+			case FAILED -> new QueryResource.FailedQueryResponse(
+					query.getId(),
+					query.getLabel(),
+					query.getCreatedAt().toString(),
+					true,
+					query.isShared(),
+					false,
+					query.getTags(),
+					query.getDefinition(),
+					query.getSecondaryId(),
+					query.getOwnerName(),
+					query.getGroups(),
+					false,
+					List.of(),
+					new QueryResource.ErrorResponse("Query failed", "FAILED")
+			);
+			case CANCELED -> new QueryResource.CanceledQueryResponse(
+					query.getId(),
+					query.getLabel(),
+					query.getCreatedAt().toString(),
+					true,
+					query.isShared(),
+					false,
+					query.getTags(),
+					query.getDefinition(),
+					query.getSecondaryId(),
+					query.getOwnerName(),
+					query.getGroups(),
+					false,
+					List.of(),
+					new QueryResource.ErrorResponse("Query canceled", "CANCELED")
+			);
+			case NEW -> new QueryResource.NewQueryResponse(
+					query.getId(),
+					query.getLabel(),
+					query.getCreatedAt().toString(),
+					true,
+					query.isShared(),
+					false,
+					query.getTags(),
+					query.getDefinition(),
+					query.getSecondaryId(),
+					query.getOwnerName(),
+					query.getGroups(),
+					false,
+					List.of()
+			);
+		};
+	}
+
+	private QueryResource.QueryDefinition toQueryDefinition(QuerySubmissionPayload payload, QueryResource.QueryType queryType) {
+		QuerySubmissionPayload.QueryNode root = extractRoot(payload);
+		return switch (queryType) {
+			case SECONDARY_ID_QUERY -> new QueryResource.SecondaryIdQueryDefinition(root, extractSecondaryId(payload));
+			case CONCEPT_QUERY -> new QueryResource.ConceptQueryDefinition(root);
+		};
+	}
+
+	private QueryResource.QueryType resolveQueryType(QuerySubmissionPayload payload) {
+		if (payload instanceof QuerySubmissionPayload.SecondaryIdQuerySubmissionPayload) {
+			return QueryResource.QueryType.SECONDARY_ID_QUERY;
+		}
+		if (payload instanceof QuerySubmissionPayload.ConceptQuerySubmissionPayload) {
+			return QueryResource.QueryType.CONCEPT_QUERY;
+		}
+		if (payload != null && payload.type != null) {
+			try {
+				return QueryResource.QueryType.valueOf(payload.type.toUpperCase(Locale.ROOT));
+			}
+			catch (IllegalArgumentException ignored) {
+				// Fall through to heuristic handling.
+			}
+		}
+		String secondaryId = extractSecondaryId(payload);
+		if (secondaryId != null && !secondaryId.isBlank()) {
+			return QueryResource.QueryType.SECONDARY_ID_QUERY;
+		}
+		return QueryResource.QueryType.CONCEPT_QUERY;
+	}
+
+	private String extractSecondaryId(QuerySubmissionPayload payload) {
+		if (payload instanceof QuerySubmissionPayload.SecondaryIdQuerySubmissionPayload secondaryIdPayload) {
+			return secondaryIdPayload.secondaryId;
+		}
+		return null;
+	}
+
+	private QuerySubmissionPayload.QueryNode extractRoot(QuerySubmissionPayload payload) {
+		if (payload instanceof QuerySubmissionPayload.ConceptQuerySubmissionPayload conceptPayload) {
+			return conceptPayload.root;
+		}
+		if (payload instanceof QuerySubmissionPayload.SecondaryIdQuerySubmissionPayload secondaryIdPayload) {
+			return secondaryIdPayload.root;
+		}
+		return null;
+	}
+
+	private boolean containsDates(QuerySubmissionPayload.QueryNode node) {
+		if (node == null) {
+			return false;
+		}
+		if (node instanceof QuerySubmissionPayload.DateRestrictionNode || node instanceof QuerySubmissionPayload.TemporalNode) {
+			return true;
+		}
+        return switch (node) {
+            case QuerySubmissionPayload.AndNode andNode -> anyContainsDates(andNode.children);
+            case QuerySubmissionPayload.OrNode orNode -> anyContainsDates(orNode.children);
+            case QuerySubmissionPayload.NegationNode negationNode -> containsDates(negationNode.child);
+            default -> false;
+        };
+    }
+
+	private boolean anyContainsDates(List<QuerySubmissionPayload.QueryNode> children) {
+		if (children == null || children.isEmpty()) {
+			return false;
+		}
+		for (QuerySubmissionPayload.QueryNode child : new ArrayList<>(children)) {
+			if (containsDates(child)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private StoredQuery requireQuery(String queryId) {
+		return metaStorage.queries().findById(queryId).orElseThrow(() -> new NotFoundException("Unknown query: " + queryId));
+	}
+
+	private static String labelFor(String queryId) {
+		return "Query " + queryId;
+	}
+
+	public record QueryPatch(
+			String label,
+			List<String> tags,
+			Boolean shared,
+			List<String> groups
+	) {
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/services/QueryUploadService.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/services/QueryUploadService.java
new file mode 100644
index 0000000000..5a3bc6116f
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/services/QueryUploadService.java
@@ -0,0 +1,48 @@
+package com.bakdata.conquery.quarkus.services;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class QueryUploadService {
+
+	public UploadResult processUpload(QueryUploadPayload payload) {
+		int expectedColumns = payload.format().size();
+		List<List<String>> unresolvedId = new ArrayList<>();
+		List<List<String>> unreadableDate = new ArrayList<>();
+		int resolved = 0;
+
+		for (List<String> row : payload.values()) {
+			if (row == null || row.isEmpty()) {
+				unresolvedId.add(List.of());
+				continue;
+			}
+			if (row.size() < expectedColumns) {
+				unresolvedId.add(List.copyOf(row));
+				continue;
+			}
+			// TODO(quarkus-migration): Implement actual ID resolution against dataset contents.
+			//  We currently only validate row shape. We still need to verify that externally
+			//  provided IDs are known in the selected dataset and mark unknown ones unresolved.
+			resolved++;
+		}
+
+		return new UploadResult(resolved, unresolvedId, unreadableDate);
+	}
+
+	public record QueryUploadPayload(
+			List<String> format,
+			List<List<String>> values,
+			String label
+	) {
+	}
+
+	public record UploadResult(
+			int resolved,
+			List<List<String>> unresolvedId,
+			List<List<String>> unreadableDate
+	) {
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/sql/SqlDatasourceRegistry.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/sql/SqlDatasourceRegistry.java
new file mode 100644
index 0000000000..d0ea321a99
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/sql/SqlDatasourceRegistry.java
@@ -0,0 +1,92 @@
+package com.bakdata.conquery.quarkus.sql;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.config.SqlRuntimeConfig;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import io.agroal.api.AgroalDataSource;
+import io.quarkus.agroal.DataSource;
+import io.quarkus.runtime.Startup;
+import jakarta.annotation.PostConstruct;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.inject.Any;
+import jakarta.enterprise.inject.Instance;
+import jakarta.inject.Inject;
+
+@ApplicationScoped
+@Startup
+public class SqlDatasourceRegistry {
+
+	@Inject
+	DatasetCatalogRepository datasetRepository;
+
+	@Inject
+	SqlRuntimeConfig sqlConfig;
+
+	@Inject
+	@Any
+	Instance<AgroalDataSource> agroalDataSources;
+
+	private Map<String, SqlDatasource> dataSourcesByName = Map.of();
+
+	@PostConstruct
+	void init() {
+		if (!sqlConfig.enabled()) {
+			return;
+		}
+
+		Map<String, SqlDatasource> resolved = new LinkedHashMap<>();
+		resolveDialectMappings(datasetRepository.listDatasets(), sqlConfig.datasources()).forEach((name, dialect) ->
+				resolved.put(name, new SqlDatasource(name, dialect, resolveAgroalDatasource(name)))
+		);
+		dataSourcesByName = Map.copyOf(resolved);
+	}
+
+	static Map<String, SqlRuntimeConfig.SqlDialect> resolveDialectMappings(
+			List<DatasetCatalogRepository.DatasetRecord> datasets,
+			Map<String, SqlRuntimeConfig.SqlDataSource> configuredDataSources
+	) {
+		Map<String, SqlRuntimeConfig.SqlDialect> resolved = new LinkedHashMap<>();
+		for (DatasetCatalogRepository.DatasetRecord dataset : datasets) {
+			String name = dataset.dataSource();
+			SqlRuntimeConfig.SqlDataSource config = Optional.ofNullable(configuredDataSources.get(name))
+					.orElseThrow(() -> new IllegalStateException(
+							"Dataset '" + dataset.id() + "' references SQL datasource '" + name
+							+ "', but conquery.sql.datasources." + name + ".dialect is not configured."
+					));
+			resolved.putIfAbsent(name, config.dialect());
+		}
+		return Map.copyOf(resolved);
+	}
+
+	public Optional<SqlDatasource> find(String name) {
+		return Optional.ofNullable(dataSourcesByName.get(name));
+	}
+
+	public SqlDatasource requireFor(DatasetCatalogRepository.DatasetRecord dataset) {
+		return find(dataset.dataSource()).orElseThrow(() -> new IllegalStateException(
+				"No active SQL datasource is registered for dataset '" + dataset.id() + "': " + dataset.dataSource()
+		));
+	}
+
+	private AgroalDataSource resolveAgroalDatasource(String name) {
+		Instance<AgroalDataSource> selected = agroalDataSources.select(new DataSource.DataSourceLiteral(name));
+		if (!selected.isResolvable()) {
+			throw new IllegalStateException(
+					"SQL datasource '" + name + "' is not a configured Quarkus named datasource. "
+					+ "Configure quarkus.datasource.\"" + name + "\".db-kind and its JDBC settings."
+			);
+		}
+		return selected.get();
+	}
+
+	public record SqlDatasource(
+			String name,
+			SqlRuntimeConfig.SqlDialect dialect,
+			AgroalDataSource dataSource
+	) {
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/ConfigDatasetCatalogRepository.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/ConfigDatasetCatalogRepository.java
new file mode 100644
index 0000000000..d4ffd43b91
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/ConfigDatasetCatalogRepository.java
@@ -0,0 +1,94 @@
+package com.bakdata.conquery.quarkus.storage;
+
+import java.util.List;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.ids.ConceptId;
+import com.bakdata.conquery.quarkus.ids.DatasetId;
+import com.bakdata.conquery.quarkus.ids.StructureNodeId;
+import com.bakdata.conquery.quarkus.ids.TableId;
+import io.quarkus.runtime.Startup;
+import jakarta.annotation.PostConstruct;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+
+@ApplicationScoped
+@Startup
+public class ConfigDatasetCatalogRepository implements DatasetCatalogRepository {
+
+	@Inject
+	DatasetMetadataFolderLoader metadataFolderLoader;
+
+	private Map<DatasetId, DatasetRecord> datasetsById = Map.of();
+	private Map<DatasetId, Map<ConceptId, Concept>> conceptsByDatasetId = Map.of();
+	private Map<DatasetId, Map<StructureNodeId, StructureNode>> structureNodesByDatasetId = Map.of();
+	private Map<DatasetId, Map<TableId, TableRecord>> tablesByDatasetId = Map.of();
+
+	@PostConstruct
+	void init() {
+		Map<DatasetId, DatasetRecord> datasetIndex = new LinkedHashMap<>();
+		Map<DatasetId, Map<ConceptId, Concept>> conceptDatasetIndex = new LinkedHashMap<>();
+		Map<DatasetId, Map<StructureNodeId, StructureNode>> structureNodeDatasetIndex = new LinkedHashMap<>();
+		Map<DatasetId, Map<TableId, TableRecord>> tableDatasetIndex = new LinkedHashMap<>();
+
+		metadataFolderLoader.loadConfiguredDatasets().forEach(dataset -> {
+			datasetIndex.put(dataset.dataset().id(), dataset.dataset());
+			conceptDatasetIndex.put(dataset.dataset().id(), new LinkedHashMap<>(dataset.conceptsById()));
+			structureNodeDatasetIndex.put(dataset.dataset().id(), new LinkedHashMap<>(dataset.structureNodesById()));
+			tableDatasetIndex.put(dataset.dataset().id(), new LinkedHashMap<>(dataset.tablesById()));
+		});
+
+		datasetsById = java.util.Collections.unmodifiableMap(new LinkedHashMap<>(datasetIndex));
+		conceptsByDatasetId = freezeNestedMap(conceptDatasetIndex);
+		structureNodesByDatasetId = freezeNestedMap(structureNodeDatasetIndex);
+		tablesByDatasetId = freezeNestedMap(tableDatasetIndex);
+	}
+
+	@Override
+	public List<DatasetRecord> listDatasets() {
+		return datasetsById.values().stream().toList();
+	}
+
+	@Override
+	public Optional<DatasetRecord> findDataset(DatasetId datasetId) {
+		return Optional.ofNullable(datasetsById.get(datasetId));
+	}
+
+	@Override
+	public List<Concept> listConceptsForDataset(DatasetId datasetId) {
+		return conceptsByDatasetId.getOrDefault(datasetId, Map.of()).values().stream().toList();
+	}
+
+	@Override
+	public Optional<Concept> findConcept(ConceptId conceptId) {
+		return Optional.ofNullable(conceptsByDatasetId.getOrDefault(conceptId.datasetId(), Map.of()).get(conceptId));
+	}
+
+	@Override
+	public List<StructureNode> listStructureNodesForDataset(DatasetId datasetId) {
+		return structureNodesByDatasetId.getOrDefault(datasetId, Map.of()).values().stream().toList();
+	}
+
+	@Override
+	public Optional<StructureNode> findStructureNode(StructureNodeId structureNodeId) {
+		return Optional.ofNullable(structureNodesByDatasetId.getOrDefault(structureNodeId.datasetId(), Map.of()).get(structureNodeId));
+	}
+
+	public List<TableRecord> listTablesForDataset(DatasetId datasetId) {
+		return tablesByDatasetId.getOrDefault(datasetId, Map.of()).values().stream().toList();
+	}
+
+	@Override
+	public Optional<TableRecord> findTable(TableId tableId) {
+		return Optional.ofNullable(tablesByDatasetId.getOrDefault(tableId.datasetId(), Map.of()).get(tableId));
+	}
+
+	private <K, T> Map<DatasetId, Map<K, T>> freezeNestedMap(Map<DatasetId, Map<K, T>> source) {
+		Map<DatasetId, Map<K, T>> result = new LinkedHashMap<>();
+		source.forEach((datasetId, entries) -> result.put(datasetId, java.util.Collections.unmodifiableMap(new LinkedHashMap<>(entries))));
+		return java.util.Collections.unmodifiableMap(result);
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/DatasetCatalogRepository.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/DatasetCatalogRepository.java
new file mode 100644
index 0000000000..b9b4a633ad
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/DatasetCatalogRepository.java
@@ -0,0 +1,219 @@
+package com.bakdata.conquery.quarkus.storage;
+
+import java.util.*;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.ConceptCondition;
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectDefinition;
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.quarkus.ids.ConceptId;
+import com.bakdata.conquery.quarkus.ids.ConceptSelectId;
+import com.bakdata.conquery.quarkus.ids.ConnectorId;
+import com.bakdata.conquery.quarkus.ids.DatasetId;
+import com.bakdata.conquery.quarkus.ids.FilterId;
+import com.bakdata.conquery.quarkus.ids.SelectId;
+import com.bakdata.conquery.quarkus.ids.StructureNodeId;
+import com.bakdata.conquery.quarkus.ids.TableId;
+import com.bakdata.conquery.quarkus.ids.ValidityDateId;
+
+public interface DatasetCatalogRepository {
+
+	List<DatasetRecord> listDatasets();
+
+	Optional<DatasetRecord> findDataset(DatasetId datasetId);
+
+	List<Concept> listConceptsForDataset(DatasetId datasetId);
+
+	Optional<Concept> findConcept(ConceptId conceptId);
+
+	List<StructureNode> listStructureNodesForDataset(DatasetId datasetId);
+
+	Optional<StructureNode> findStructureNode(StructureNodeId structureNodeId);
+
+	List<TableRecord> listTablesForDataset(DatasetId datasetId);
+
+	Optional<TableRecord> findTable(TableId tableId);
+
+	record DatasetRecord(
+			DatasetId id,
+			String label,
+			String dataSource
+	) {
+		public DatasetRecord {
+			if (dataSource == null || dataSource.isBlank()) {
+				dataSource = id.toString();
+			}
+		}
+	}
+
+	record ConceptElement(
+			ConceptId id,
+			String label,
+			String description,
+			List<AdditionalInfo> additionalInfos,
+			ConceptId parentId,
+			List<ConceptId> children,
+			ConceptCondition condition
+	) {
+		public ConceptElement(ConceptId id, String label, String description) {
+			this(id, label, description, List.of(), null, List.of(), null);
+		}
+
+		public ConceptElement {
+			additionalInfos = additionalInfos == null ? List.of() : List.copyOf(additionalInfos);
+			children = children == null ? List.of() : List.copyOf(children);
+		}
+
+	}
+
+	record Concept(
+			ConceptId id,
+			String label,
+			String description,
+			List<AdditionalInfo> additionalInfos,
+			boolean defaultExcludeFromTimeAggregation,
+			// All Children flat lookup
+			Map<ConceptId,ConceptElement> children,
+			// Direct children
+			List<ConceptId> childrenIds,
+			List<Connector> connectors,
+			List<ConceptSelect> selects
+
+	){
+		public Concept {
+			additionalInfos = additionalInfos == null ? List.of() : List.copyOf(additionalInfos);
+			selects = selects == null ? List.of() : List.copyOf(selects);
+		}
+	}
+
+	record AdditionalInfo(String key, String value) {
+	}
+
+	record StructureNode(
+			StructureNodeId id,
+			String label,
+			String description,
+			int sourceOrder,
+			StructureNodeId parentId,
+			List<StructureNodeId> children,
+			List<ConceptId> containedRoots
+	) {
+		public StructureNode {
+			children = children == null ? List.of() : List.copyOf(children);
+			containedRoots = containedRoots == null ? List.of() : List.copyOf(containedRoots);
+		}
+
+		// TODO Add structure-node additionalInfos once the shared frontend metadata model is migrated.
+	}
+
+	record Connector(
+			ConnectorId id,
+			TableId tableId,
+			ColumnId columnId,
+			String label,
+			String name,
+			List<Select> selects,
+			List<Filter> filters,
+			String validityDatesDescription,
+			List<ValidityDate> validityDates,
+			boolean isDefault
+	){
+		public DatasetId datasetId() {
+			return id.datasetId();
+		}
+	}
+
+	record ValidityDate(
+			ValidityDateId id,
+			String label,
+			ColumnId columnId,
+			ColumnId startColumnId,
+			ColumnId endColumnId
+	) {}
+
+	record Select(
+			SelectId id,
+			SelectDefinition definition,
+			String label,
+			String description,
+			boolean defaultSelected,
+			String implementationType,
+			SelectResultType resultType,
+			List<ColumnId> requiredColumns
+	) {
+		public Select {
+			requiredColumns = requiredColumns == null ? List.of() : List.copyOf(requiredColumns);
+		}
+	}
+
+	record ConceptSelect(
+			ConceptSelectId id,
+			ConceptSelectDefinition definition,
+			String label,
+			String description,
+			boolean defaultSelected,
+			String implementationType,
+			SelectResultType resultType
+	) {
+	}
+
+	record SelectResultType(String type, SelectResultType elementType) {
+		public static SelectResultType primitive(String type) {
+			return new SelectResultType(type, null);
+		}
+
+		public static SelectResultType list(SelectResultType elementType) {
+			return new SelectResultType("LIST", elementType);
+		}
+	}
+	record Filter(
+			FilterId id,
+			FilterDefinition definition,
+			String label,
+			String type,
+			String unit,
+			String tooltip,
+			List<FrontendValue> options,
+			Integer min,
+			Integer max,
+			String pattern,
+			boolean allowDropFile,
+			boolean creatable,
+			Object defaultValue,
+			List<ColumnId> requiredColumns
+	) {
+		public Filter {
+			options = options == null ? List.of() : List.copyOf(options);
+			requiredColumns = requiredColumns == null ? List.of() : List.copyOf(requiredColumns);
+		}
+	}
+
+	record FrontendValue(
+			String value,
+			String label,
+			String optionValue
+	) {
+	}
+
+	record TableRecord(
+			TableId id,
+			String label,
+			List<ColumnRecord> columns,
+			ColumnId primaryColumn
+	) {
+		public TableRecord {
+			columns = columns == null ? List.of() : List.copyOf(columns);
+		}
+	}
+
+	record ColumnRecord(
+			ColumnId id,
+			String label,
+			ColumnType type,
+			String secondaryId
+	) {
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/DatasetMetadataFolderLoader.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/DatasetMetadataFolderLoader.java
new file mode 100644
index 0000000000..8e6ffd3590
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/DatasetMetadataFolderLoader.java
@@ -0,0 +1,651 @@
+package com.bakdata.conquery.quarkus.storage;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Stream;
+import java.util.stream.Collectors;
+
+import com.bakdata.conquery.quarkus.config.DatasetMetadataRuntimeConfig;
+import com.bakdata.conquery.quarkus.concepts.conditions.ConceptCondition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.FilterDefinitionAssembler;
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinition;
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinitionAssembler;
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectDefinition;
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectDefinitionAssembler;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.quarkus.ids.ConceptId;
+import com.bakdata.conquery.quarkus.ids.ConnectorId;
+import com.bakdata.conquery.quarkus.ids.DatasetId;
+import com.bakdata.conquery.quarkus.ids.IdPartSanitizer;
+import com.bakdata.conquery.quarkus.ids.StructureNodeId;
+import com.bakdata.conquery.quarkus.ids.TableId;
+import com.bakdata.conquery.quarkus.ids.ValidityDateId;
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.fasterxml.jackson.annotation.JsonAlias;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import jakarta.validation.*;
+import jakarta.validation.constraints.NotNull;
+import lombok.extern.slf4j.Slf4j;
+
+@ApplicationScoped
+@Slf4j
+public class DatasetMetadataFolderLoader {
+
+	@Inject
+	DatasetMetadataRuntimeConfig metadataConfig;
+
+	@Inject
+	ObjectMapper objectMapper;
+
+	@Inject
+	Validator validator;
+
+	@Inject
+	FilterDefinitionAssembler filterDefinitionAssembler;
+
+	@Inject
+	SelectDefinitionAssembler selectDefinitionAssembler;
+
+	@Inject
+	ConceptSelectDefinitionAssembler conceptSelectDefinitionAssembler;
+
+	public List<LoadedDatasetMetadata> loadConfiguredDatasets() {
+		if (!metadataConfig.enabled()) {
+			return List.of();
+		}
+
+		String rootPath = metadataConfig.rootPath().orElseThrow(() -> new IllegalStateException("conquery.metadata.root-path is required when metadata ingestion is enabled."));
+		List<String> folders = metadataConfig.folders().orElseThrow(() -> new IllegalStateException("conquery.metadata.folders must contain at least one folder when metadata ingestion is enabled."));
+		if (folders.isEmpty()) {
+			throw new IllegalStateException("conquery.metadata.folders must not be empty when metadata ingestion is enabled.");
+		}
+
+		Map<DatasetId, LoadedDatasetMetadata> loadedByDatasetId = new LinkedHashMap<>();
+		Path root = Path.of(rootPath);
+		for (String configuredFolder : folders) {
+			Path folderPath = toFolderPath(root, configuredFolder);
+			LoadedDatasetMetadata loaded = loadDatasetFolder(folderPath);
+			LoadedDatasetMetadata previous = loadedByDatasetId.put(loaded.dataset().id(), loaded);
+			if (previous != null) {
+				throw new IllegalStateException("Duplicate dataset id '" + loaded.dataset().id() + "' across configured metadata folders.");
+			}
+		}
+
+		return loadedByDatasetId.values().stream().toList();
+	}
+
+	private LoadedDatasetMetadata loadDatasetFolder(Path folderPath) {
+		if (!Files.isDirectory(folderPath)) {
+			throw new IllegalStateException("Configured metadata folder does not exist or is not a directory: " + folderPath);
+		}
+
+		String folderName = folderPath.getFileName() == null ? folderPath.toString() : folderPath.getFileName().toString();
+		DatasetPayload datasetPayload = loadDatasetPayload(folderPath).orElse(new DatasetPayload(null, null, null));
+		DatasetId datasetId = DatasetId.parse(idPartFromPreferredOrFallback(datasetPayload.id(), folderName, "dataset id", folderPath));
+		String datasetLabel = firstNonBlank(datasetPayload.label(), folderName).orElse(folderName);
+		String dataSource = firstNonBlank(datasetPayload.dataSource(), datasetId.toString()).orElse(datasetId.toString());
+		DatasetCatalogRepository.DatasetRecord dataset = new DatasetCatalogRepository.DatasetRecord(datasetId, datasetLabel, dataSource);
+
+		Map<TableId, DatasetCatalogRepository.TableRecord> tablesById = loadTables(folderPath, datasetId);
+		Map<ConceptId, DatasetCatalogRepository.Concept> conceptsById = loadConcepts(folderPath, datasetId, tablesById);
+		Map<StructureNodeId, DatasetCatalogRepository.StructureNode> structureNodesById = loadStructureNodes(folderPath, datasetId, conceptsById);
+
+		log.debug("Loaded dataset {} with {} concepts, {} structure nodes, and {} tables", datasetId, conceptsById.size(), structureNodesById.size(), tablesById.size());
+		return new LoadedDatasetMetadata(dataset, Map.copyOf(conceptsById), Map.copyOf(structureNodesById), Map.copyOf(tablesById));
+	}
+
+	private Map<StructureNodeId, DatasetCatalogRepository.StructureNode> loadStructureNodes(
+			Path folderPath,
+			DatasetId datasetId,
+			Map<ConceptId, DatasetCatalogRepository.Concept> conceptsById
+	) {
+		Map<StructureNodeId, DatasetCatalogRepository.StructureNode> nodesById = new LinkedHashMap<>();
+		Map<ConceptId, StructureNodeId> placementByConcept = new LinkedHashMap<>();
+		AtomicInteger nextSourceOrder = new AtomicInteger();
+		try (Stream<Path> files = Files.list(folderPath)) {
+			files.filter(Files::isRegularFile)
+					.filter(path -> path.getFileName().toString().startsWith("structure"))
+					.filter(path -> path.getFileName().toString().endsWith(".json"))
+					.sorted()
+					.forEach(path -> {
+						StructureNodePayload[] roots = read(path, StructureNodePayload[].class);
+						for (StructureNodePayload root : roots) {
+							validate(path, root);
+							collectStructureNode(path, root, datasetId, null, conceptsById, nodesById, placementByConcept, nextSourceOrder);
+						}
+					});
+		}
+		catch (IOException e) {
+			throw new IllegalStateException("Failed to list structure metadata in " + folderPath, e);
+		}
+		return nodesById;
+	}
+
+	private StructureNodeId collectStructureNode(
+			Path source,
+			StructureNodePayload payload,
+			DatasetId datasetId,
+			StructureNodeId parentId,
+			Map<ConceptId, DatasetCatalogRepository.Concept> conceptsById,
+			Map<StructureNodeId, DatasetCatalogRepository.StructureNode> nodesById,
+			Map<ConceptId, StructureNodeId> placementByConcept,
+			AtomicInteger nextSourceOrder
+	) {
+		int sourceOrder = nextSourceOrder.getAndIncrement();
+		String name = idPartFromPreferredOrFallback(payload.name(), payload.label(), "structure node id", source);
+		StructureNodeId id = parentId == null
+				? new StructureNodeId(datasetId, List.of(name))
+				: parentId.child(name);
+		ConceptId collidingConceptId = new ConceptId(datasetId, id.path());
+		if (conceptsById.containsKey(collidingConceptId)) {
+			throw new IllegalStateException("Structure node '" + id + "' collides with concept id '" + collidingConceptId + "' in " + source + ".");
+		}
+		List<StructureNodeId> childIds = Optional.ofNullable(payload.children()).orElse(List.of()).stream()
+				.map(child -> collectStructureNode(source, child, datasetId, id, conceptsById, nodesById, placementByConcept, nextSourceOrder))
+				.toList();
+		List<ConceptId> containedRoots = Optional.ofNullable(payload.containedRoots()).orElse(List.of()).stream()
+				.map(value -> resolveStructureConceptId(source, id, datasetId, value, conceptsById))
+				.toList();
+		for (ConceptId conceptId : containedRoots) {
+			StructureNodeId previous = placementByConcept.put(conceptId, id);
+			if (previous != null) {
+				throw new IllegalStateException("Concept '" + conceptId + "' is contained by multiple structure nodes: '" + previous + "' and '" + id + "'.");
+			}
+		}
+		String label = firstNonBlank(payload.label(), payload.name(), name).orElse(name);
+		DatasetCatalogRepository.StructureNode node = new DatasetCatalogRepository.StructureNode(id, label, payload.description(), sourceOrder, parentId, childIds, containedRoots);
+		DatasetCatalogRepository.StructureNode previous = nodesById.put(id, node);
+		if (previous != null) {
+			throw new IllegalStateException("Duplicate structure node id '" + id + "' in " + source + ".");
+		}
+		return id;
+	}
+
+	private ConceptId resolveStructureConceptId(
+			Path source,
+			StructureNodeId structureNodeId,
+			DatasetId datasetId,
+			String value,
+			Map<ConceptId, DatasetCatalogRepository.Concept> conceptsById
+	) {
+		String rawId = normalizeBlank(value)
+				.orElseThrow(() -> new IllegalStateException("Structure node '" + structureNodeId + "' contains a blank concept reference in " + source + "."));
+		ConceptId conceptId;
+		if (rawId.equals(datasetId.toString()) || rawId.startsWith(datasetId + ".")) {
+			conceptId = ConceptId.parse(rawId);
+		}
+		else {
+			conceptId = new ConceptId(datasetId, Arrays.asList(rawId.split("\\.")));
+		}
+		if (!conceptsById.containsKey(conceptId)) {
+			throw new IllegalStateException("Structure node '" + structureNodeId + "' references unknown concept '" + conceptId + "' in " + source + ".");
+		}
+		return conceptId;
+	}
+
+	private Map<ConceptId, DatasetCatalogRepository.Concept> loadConcepts(Path folderPath, DatasetId datasetId, Map<TableId, DatasetCatalogRepository.TableRecord> tablesById) {
+		Path conceptsDir = folderPath.resolve("conceptTrees");
+		if (!Files.isDirectory(conceptsDir)) {
+			throw new IllegalStateException("Metadata folder is missing conceptTrees/: " + folderPath);
+		}
+
+		Map<ConceptId, DatasetCatalogRepository.Concept> conceptsById = new LinkedHashMap<>();
+		try (Stream<Path> files = Files.list(conceptsDir)) {
+			files.filter(Files::isRegularFile).filter(path -> path.getFileName().toString().endsWith(".concept.json")).sorted().forEach(path -> {
+				ConceptPayload payload = read(path, ConceptPayload.class);
+				validate(path, payload);
+				String conceptName = idPartFromPreferredOrFallback(payload.name(), stripSuffix(path.getFileName().toString(), ".concept.json"), "concept id", path);
+				ConceptId conceptId = conceptName.equals(datasetId.name()) ? new ConceptId(datasetId, List.of()) : new ConceptId(datasetId, List.of(conceptName));
+				conceptsById.put(conceptId, collectConcept(payload, conceptId, tablesById));
+			});
+		} catch (IOException e) {
+			throw new IllegalStateException("Failed to list concept metadata in " + conceptsDir, e);
+		}
+
+		log.debug("Loaded dataset {} with {} concepts", datasetId, conceptsById.size());
+		return conceptsById;
+	}
+
+	private DatasetCatalogRepository.Concept collectConcept(ConceptPayload payload, ConceptId conceptId, Map<TableId, DatasetCatalogRepository.TableRecord> tablesById) {
+		String conceptLabel = firstNonBlank(payload.label()).orElseGet(() -> payload.name);
+		List<ConceptElementPayload> children = Optional.ofNullable(payload.children()).orElse(List.of());
+		FallbackLogCollector fallbackLogCollector = new FallbackLogCollector(conceptId);
+
+		Map<ConceptId, DatasetCatalogRepository.ConceptElement> conceptElementsById = new LinkedHashMap<>();
+		List<ConceptId> directChildIds = children.stream().map(child -> childId(conceptId, child, fallbackLogCollector)).toList();
+
+		for (int index = 0; index < children.size(); index++) {
+			collectConceptChildren(children.get(index), directChildIds.get(index), conceptId, conceptElementsById, fallbackLogCollector);
+		}
+
+		List<DatasetCatalogRepository.Connector> connectors = payload.connectors().stream().map(p -> {
+
+			DatasetId datasetId = conceptId.datasetId();
+			String tableName = normalizeBlank(p.table)
+					.orElseThrow(() -> new IllegalStateException("Connector '" + p.name + "' in concept '" + conceptId + "' must define a table."));
+			TableId tableId = toConnectorTableId(datasetId, tableName);
+			DatasetCatalogRepository.TableRecord table = Optional.ofNullable(tablesById.get(tableId))
+					.orElseThrow(() -> new IllegalStateException("Connector '" + p.name + "' in concept '" + conceptId + "' references unknown table '" + tableId + "'."));
+			String columnName = p.column;
+			if (columnName != null) {
+				columnName = normalizeLocalColumnName(columnName);
+			}
+
+			ConnectorId connectorId = new ConnectorId(conceptId, p.name);
+			List<DatasetCatalogRepository.ValidityDate> validityDates = assembleValidityDates(
+					connectorId, tableId, table, p.validityDates(), fallbackLogCollector
+			);
+			return new DatasetCatalogRepository.Connector(
+					connectorId,
+					tableId,
+					columnName == null ? null : new ColumnId(tableId, columnName),
+					p.label,
+					p.name,
+					selectDefinitionAssembler.assemble(connectorId, tableId, table, p.selects(), fallbackLogCollector::add, metadataConfig.strictSelectTypes()),
+					filterDefinitionAssembler.assemble(connectorId, tableId, table, p.filters(), fallbackLogCollector::add, metadataConfig.strictFilterTypes()),
+					p.validityDatesDescription(),
+					validityDates,
+					p.isDefault == null || p.isDefault
+			);
+
+		}).toList();
+
+		List<DatasetCatalogRepository.ConceptSelect> selects = conceptSelectDefinitionAssembler.assemble(
+				conceptId, payload.selects(), fallbackLogCollector::add, metadataConfig.strictSelectTypes()
+		);
+
+		log.debug("Loaded concept {} with {} children", conceptId, children.size());
+		fallbackLogCollector.logSummary();
+
+		return new DatasetCatalogRepository.Concept(
+				conceptId,
+				conceptLabel,
+				payload.description,
+				copyAdditionalInfos(payload.additionalInfos()),
+				Boolean.TRUE.equals(payload.defaultExcludeFromTimeAggregation()),
+				Map.copyOf(conceptElementsById),
+				directChildIds,
+				connectors,
+				selects
+		);
+	}
+
+	private List<DatasetCatalogRepository.ValidityDate> assembleValidityDates(
+			ConnectorId connectorId,
+			TableId tableId,
+			DatasetCatalogRepository.TableRecord table,
+			List<ValidityDatePayload> payloads,
+			FallbackLogCollector fallbackLogCollector
+	) {
+		Map<String, DatasetCatalogRepository.ColumnRecord> columnsByName = table.columns().stream()
+				.collect(Collectors.toMap(column -> column.id().name(), column -> column));
+		Set<ValidityDateId> ids = new HashSet<>();
+		List<DatasetCatalogRepository.ValidityDate> validityDates = new ArrayList<>();
+		for (ValidityDatePayload payload : Optional.ofNullable(payloads).orElse(List.of())) {
+			String name = idPartFromPreferredOrFallback(
+					payload.name(), payload.label(), "validity date id", connectorId, fallbackLogCollector
+			);
+			ValidityDateId id = new ValidityDateId(connectorId, name);
+			if (!ids.add(id)) {
+				throw new IllegalStateException("Connector '" + connectorId + "' contains duplicate validity date id '" + id + "'.");
+			}
+
+			boolean hasColumn = normalizeBlank(payload.column()).isPresent();
+			boolean hasStartColumn = normalizeBlank(payload.startColumn()).isPresent();
+			boolean hasEndColumn = normalizeBlank(payload.endColumn()).isPresent();
+			if (hasColumn == (hasStartColumn || hasEndColumn) || hasStartColumn != hasEndColumn) {
+				throw new IllegalStateException("Validity date '" + id + "' must define either column or both startColumn and endColumn.");
+			}
+
+			ColumnId columnId = hasColumn ? requireValidityDateColumn(id, tableId, columnsByName, payload.column()) : null;
+			ColumnId startColumnId = hasStartColumn ? requireValidityDateColumn(id, tableId, columnsByName, payload.startColumn()) : null;
+			ColumnId endColumnId = hasEndColumn ? requireValidityDateColumn(id, tableId, columnsByName, payload.endColumn()) : null;
+			String label = firstNonBlank(payload.label(), payload.name(), name).orElse(name);
+			validityDates.add(new DatasetCatalogRepository.ValidityDate(id, label, columnId, startColumnId, endColumnId));
+		}
+		return List.copyOf(validityDates);
+	}
+
+	private ColumnId requireValidityDateColumn(
+			ValidityDateId validityDateId,
+			TableId tableId,
+			Map<String, DatasetCatalogRepository.ColumnRecord> columnsByName,
+			String rawColumnName
+	) {
+		String columnName = normalizeLocalColumnName(rawColumnName);
+		DatasetCatalogRepository.ColumnRecord column = columnsByName.get(columnName);
+		if (column == null) {
+			throw new IllegalStateException("Validity date '" + validityDateId + "' references unknown column '" + columnName + "' in table '" + tableId + "'.");
+		}
+		if (column.type() != ColumnType.DATE && column.type() != ColumnType.DATE_RANGE) {
+			throw new IllegalStateException("Validity date '" + validityDateId + "' references non-date column '" + column.id() + "'.");
+		}
+		return column.id();
+	}
+
+	private void collectConceptChildren(ConceptElementPayload payload, ConceptId conceptId, ConceptId parentId, Map<ConceptId, DatasetCatalogRepository.ConceptElement> conceptElementsById, FallbackLogCollector fallbackLogCollector) {
+		String conceptLabel = firstNonBlank(payload.label()).orElse(payload.name);
+		List<ConceptElementPayload> children = Optional.ofNullable(payload.children()).orElse(List.of());
+		List<ConceptId> childIds = children.stream().map(child -> childId(conceptId, child, fallbackLogCollector)).toList();
+		conceptElementsById.put(conceptId, new DatasetCatalogRepository.ConceptElement(
+				conceptId, conceptLabel, payload.description, copyAdditionalInfos(payload.additionalInfos()), parentId, childIds, payload.condition()
+		));
+		for (int index = 0; index < children.size(); index++) {
+			collectConceptChildren(children.get(index), childIds.get(index), conceptId, conceptElementsById, fallbackLogCollector);
+		}
+	}
+
+	private List<DatasetCatalogRepository.AdditionalInfo> copyAdditionalInfos(List<DatasetCatalogRepository.AdditionalInfo> additionalInfos) {
+		return List.copyOf(Optional.ofNullable(additionalInfos).orElse(List.of()));
+	}
+
+
+	private ConceptId childId(ConceptId parentId, ConceptElementPayload child, FallbackLogCollector fallbackLogCollector) {
+		String childName = idPartFromPreferredOrFallback(child.name(), child.label(), "concept child id", parentId, fallbackLogCollector);
+		return parentId.child(childName);
+	}
+
+	private TableId toConnectorTableId(DatasetId datasetId, String rawTableName) {
+		String tableName = rawTableName;
+		if (tableName.startsWith(datasetId + ".")) {
+			tableName = tableName.substring(datasetId.toString().length() + 1);
+		}
+		return new TableId(datasetId, tableName);
+	}
+
+	private Map<TableId, DatasetCatalogRepository.TableRecord> loadTables(Path folderPath, DatasetId datasetId) {
+		Path tablesDir = folderPath.resolve("tables");
+		if (!Files.isDirectory(tablesDir)) {
+			throw new IllegalStateException("Metadata folder is missing tables/: " + folderPath);
+		}
+
+		Map<TableId, DatasetCatalogRepository.TableRecord> tablesById = new LinkedHashMap<>();
+		try (Stream<Path> files = Files.list(tablesDir)) {
+			files.filter(Files::isRegularFile).filter(path -> path.getFileName().toString().endsWith(".table.json")).sorted().forEach(path -> {
+				TablePayload payload = read(path, TablePayload.class);
+				String tableName = idPartFromPreferredOrFallback(payload.name(), stripSuffix(path.getFileName().toString(), ".table.json"), "table id", path);
+				TableId tableId = new TableId(datasetId, tableName);
+				String tableLabel = firstNonBlank(payload.label(), tableName).orElse(tableName);
+				List<DatasetCatalogRepository.ColumnRecord> columns = Optional.ofNullable(payload.columns()).orElse(List.of()).stream().map(column -> toColumn(datasetId, tableName, tableId, column)).toList();
+				ColumnId primaryColumn = toColumnId(datasetId, tableName, tableId, payload.primaryColumn()).orElse(null);
+				tablesById.put(tableId, new DatasetCatalogRepository.TableRecord(tableId, tableLabel, columns, primaryColumn));
+			});
+		} catch (IOException e) {
+			throw new IllegalStateException("Failed to list table metadata in " + tablesDir, e);
+		}
+
+		return tablesById;
+	}
+
+	private DatasetCatalogRepository.ColumnRecord toColumn(DatasetId datasetId, String tableName, TableId tableId, ColumnPayload payload) {
+		String rawColumnName = firstNonBlank(payload.name(), payload.id()).orElseThrow(() -> new IllegalStateException("Column entry is missing a name/id in table " + tableId));
+		ColumnId columnId = toColumnId(datasetId, tableName, tableId, rawColumnName).orElseThrow(() -> new IllegalStateException("Column id must not be blank in table " + tableId));
+		String columnLabel = firstNonBlank(payload.label(), rawColumnName).orElse(rawColumnName);
+		ColumnType type = parseColumnType(payload.type());
+		String secondaryId = normalizeBlank(payload.secondaryId()).orElse(null);
+		return new DatasetCatalogRepository.ColumnRecord(columnId, columnLabel, type, secondaryId);
+	}
+
+	private Optional<ColumnId> toColumnId(DatasetId datasetId, String tableName, TableId tableId, String rawId) {
+		Optional<String> value = normalizeBlank(rawId);
+		// TODO check if this handling is necessary and correct
+		if (value.isEmpty()) {
+			return Optional.empty();
+		}
+		String id = value.get();
+		if (id.startsWith(tableId + ".")) {
+			return Optional.of(ColumnId.parse(id));
+		}
+		if (id.startsWith(tableName + ".")) {
+			return Optional.of(ColumnId.parse(datasetId + "." + id));
+		}
+		if (id.startsWith(datasetId + ".") && id.contains(".")) {
+			// TODO this looks like it's not necessarily including the table name
+			return Optional.of(ColumnId.parse(id));
+		}
+		if (id.contains(".")) {
+			return Optional.of(ColumnId.parse(datasetId + "." + id));
+		}
+		return Optional.of(new ColumnId(tableId, id));
+	}
+
+	private String normalizeLocalColumnName(String rawColumnName) {
+		String columnName = normalizeBlank(rawColumnName).orElseThrow(() -> new IllegalStateException("Connector column" + " must not be blank."));
+		if (columnName.contains(".")) {
+			throw new IllegalStateException("Connector column must reference a local column name without dots: " + rawColumnName);
+		}
+		return columnName;
+	}
+
+	private Optional<DatasetPayload> loadDatasetPayload(Path folderPath) {
+		Path datasetFile = folderPath.resolve("dataset.json");
+		if (!Files.isRegularFile(datasetFile)) {
+			return Optional.empty();
+		}
+		return Optional.of(read(datasetFile, DatasetPayload.class));
+	}
+
+	private <T> T read(Path path, Class<T> type) {
+		try {
+			return objectMapper.readValue(path.toFile(), type);
+		} catch (IOException e) {
+			throw new IllegalStateException("Failed to parse metadata file: " + path, e);
+		}
+	}
+
+	private <T> void validate(Path path, T payload) {
+		Set<ConstraintViolation<T>> violations = validator.validate(payload);
+		if (violations.isEmpty()) {
+			return;
+		}
+		String details = violations.stream()
+				.sorted(Comparator.comparing(violation -> violation.getPropertyPath().toString()))
+				.map(violation -> " - %s: %s (invalid value: %s)".formatted(
+						propertyPath(violation),
+						violation.getMessage(),
+						formatInvalidValue(violation.getInvalidValue())
+				))
+				.collect(Collectors.joining(System.lineSeparator()));
+		String message = "Failed to validate metadata file '%s':%n%s".formatted(path, details);
+		log.error("{}", message);
+		throw new ConstraintViolationException(message, violations);
+	}
+
+	private String propertyPath(ConstraintViolation<?> violation) {
+		String path = violation.getPropertyPath().toString();
+		return path.isBlank() ? "<document>" : path;
+	}
+
+	private String formatInvalidValue(Object invalidValue) {
+		String value = objectMapper.valueToTree(invalidValue).toString();
+		int limit = 200;
+		return value.length() <= limit ? value : value.substring(0, limit) + "...";
+	}
+
+	private Path toFolderPath(Path root, String configuredFolder) {
+		String value = normalizeBlank(configuredFolder).orElseThrow(() -> new IllegalStateException("conquery.metadata.folders must not contain blank entries."));
+		Path configuredPath = Path.of(value);
+		return configuredPath.isAbsolute() ? configuredPath : root.resolve(configuredPath);
+	}
+
+	private ColumnType parseColumnType(String rawType) {
+		String type = normalizeBlank(rawType).orElseThrow(() -> new IllegalStateException("Table column type must not be blank."));
+		try {
+			return ColumnType.valueOf(type.trim().toUpperCase(java.util.Locale.ROOT));
+		} catch (Exception e) {
+			throw new IllegalStateException("Unsupported table column type: " + rawType, e);
+		}
+	}
+
+	private Optional<String> firstNonBlank(String... candidates) {
+		for (String candidate : candidates) {
+			Optional<String> value = normalizeBlank(candidate);
+			if (value.isPresent()) {
+				return value;
+			}
+		}
+		return Optional.empty();
+	}
+
+	private String idPartFromPreferredOrFallback(String preferred, String fallback, String idType, Object context) {
+		return idPartFromPreferredOrFallback(preferred, fallback, idType, context, null);
+	}
+
+	private String idPartFromPreferredOrFallback(String preferred, String fallback, String idType, Object context, FallbackLogCollector fallbackLogCollector) {
+		Optional<String> preferredValue = normalizeBlank(preferred);
+		if (preferredValue.isPresent()) {
+			return preferredValue.get();
+		}
+		String fallbackValue = normalizeBlank(fallback)
+				.orElseThrow(() -> new IllegalStateException("Cannot derive " + idType + " for " + context + " because preferred and fallback values are blank."));
+		String sanitized = IdPartSanitizer.sanitize(fallbackValue, idType + " fallback");
+		if (fallbackLogCollector != null) {
+			fallbackLogCollector.add(idType, context, fallbackValue, sanitized);
+			return sanitized;
+		}
+		if (sanitized.equals(fallbackValue)) {
+			log.info("Using {} fallback '{}' for {}", idType, sanitized, context);
+		}
+		else {
+			log.info("Using sanitized {} fallback '{}' -> '{}' for {}", idType, fallbackValue, sanitized, context);
+		}
+		return sanitized;
+	}
+
+	private record FallbackLogEntry(
+			String idType,
+			Object context,
+			String fallbackValue,
+			String sanitized
+	) {
+		String message() {
+			if (sanitized.equals(fallbackValue)) {
+				return "Using " + idType + " fallback '" + sanitized + "' for " + context;
+			}
+			return "Using sanitized " + idType + " fallback '" + fallbackValue + "' -> '" + sanitized + "' for " + context;
+		}
+	}
+
+	private static final class FallbackLogCollector {
+		private static final int INFO_LIMIT = 5;
+
+		private final ConceptId conceptId;
+		private final List<FallbackLogEntry> entries = new ArrayList<>();
+
+		private FallbackLogCollector(ConceptId conceptId) {
+			this.conceptId = conceptId;
+		}
+
+		private void add(String idType, Object context, String fallbackValue, String sanitized) {
+			entries.add(new FallbackLogEntry(idType, context, fallbackValue, sanitized));
+		}
+
+		private void logSummary() {
+			if (entries.isEmpty()) {
+				return;
+			}
+			if (log.isTraceEnabled()) {
+				entries.forEach(entry -> log.trace("{}", entry.message()));
+				return;
+			}
+			entries.stream()
+				   .limit(INFO_LIMIT)
+				   .forEach(entry -> log.info("{}", entry.message()));
+			int remaining = entries.size() - INFO_LIMIT;
+			if (remaining > 0) {
+				log.info("Suppressed {} additional id fallback messages for concept {}. Enable trace logging to show all.", remaining, conceptId);
+			}
+		}
+	}
+
+	private Optional<String> normalizeBlank(String value) {
+		if (value == null) {
+			return Optional.empty();
+		}
+		String trimmed = value.trim();
+		return trimmed.isEmpty() ? Optional.empty() : Optional.of(trimmed);
+	}
+
+	private String stripSuffix(String fileName, String suffix) {
+		if (fileName.endsWith(suffix)) {
+			return fileName.substring(0, fileName.length() - suffix.length());
+		}
+		return fileName;
+	}
+
+	public record LoadedDatasetMetadata(
+			DatasetCatalogRepository.DatasetRecord dataset, Map<ConceptId, DatasetCatalogRepository.Concept> conceptsById,
+			Map<StructureNodeId, DatasetCatalogRepository.StructureNode> structureNodesById,
+			Map<TableId, DatasetCatalogRepository.TableRecord> tablesById
+	) {
+	}
+
+	@JsonIgnoreProperties(ignoreUnknown = true)
+	private record DatasetPayload(
+			String id, String label, String dataSource
+	) {
+	}
+
+	@JsonIgnoreProperties(ignoreUnknown = true)
+	private record ConceptPayload(
+			String name, String label, String description,
+			List<DatasetCatalogRepository.AdditionalInfo> additionalInfos,
+			Boolean defaultExcludeFromTimeAggregation,
+			List<@Valid ConceptElementPayload> children,
+			@NotNull @Valid List<@Valid ConnectorPayload> connectors,
+			List<@Valid ConceptSelectDefinition> selects
+	) {
+	}
+
+	@JsonIgnoreProperties(ignoreUnknown = true)
+	private record ConceptElementPayload(
+			String name, String label, String description,
+			List<DatasetCatalogRepository.AdditionalInfo> additionalInfos,
+			List<@Valid ConceptElementPayload> children,
+			@Valid ConceptCondition condition
+	) {
+	}
+
+	@JsonIgnoreProperties(ignoreUnknown = true)
+	private record StructureNodePayload(
+			String name, String label, String description,
+			List<@Valid StructureNodePayload> children,
+			List<String> containedRoots
+	) {
+	}
+
+	private record ConnectorPayload(
+			String table, String column, String label, String name, List<@Valid SelectDefinition> selects,
+			List<@Valid FilterDefinition> filters,
+			@JsonAlias("validityDatesTooltip") String validityDatesDescription,
+			List<ValidityDatePayload> validityDates, @JsonProperty("default") Boolean isDefault
+	) {
+	}
+
+	@JsonIgnoreProperties(ignoreUnknown = true)
+	private record ValidityDatePayload(
+			String name, String label, String column, String startColumn, String endColumn
+	) {
+	}
+
+	@JsonIgnoreProperties(ignoreUnknown = true)
+	private record TablePayload(
+			String name, String label, String primaryColumn, List<ColumnPayload> columns
+	) {
+	}
+
+	@JsonIgnoreProperties(ignoreUnknown = true)
+	private record ColumnPayload(
+			String id, String name, String label, String type, String secondaryId
+	) {
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/FormConfigRepository.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/FormConfigRepository.java
new file mode 100644
index 0000000000..c6dec5a304
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/FormConfigRepository.java
@@ -0,0 +1,17 @@
+package com.bakdata.conquery.quarkus.storage;
+
+import java.util.List;
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.storage.model.StoredFormConfig;
+
+public interface FormConfigRepository {
+
+	void save(StoredFormConfig config);
+
+	Optional<StoredFormConfig> findById(String formConfigId);
+
+	List<StoredFormConfig> listByDataset(String datasetId);
+
+	boolean deleteById(String formConfigId);
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/InMemoryFormConfigRepository.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/InMemoryFormConfigRepository.java
new file mode 100644
index 0000000000..98dd29de97
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/InMemoryFormConfigRepository.java
@@ -0,0 +1,37 @@
+package com.bakdata.conquery.quarkus.storage;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.bakdata.conquery.quarkus.storage.model.StoredFormConfig;
+import io.quarkus.arc.properties.IfBuildProperty;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+@IfBuildProperty(name = "conquery.storage.backend", stringValue = "IN_MEMORY", enableIfMissing = true)
+public class InMemoryFormConfigRepository implements FormConfigRepository {
+
+	private final Map<String, StoredFormConfig> configsById = new ConcurrentHashMap<>();
+
+	@Override
+	public void save(StoredFormConfig config) {
+		configsById.put(config.getId(), config);
+	}
+
+	@Override
+	public Optional<StoredFormConfig> findById(String formConfigId) {
+		return Optional.ofNullable(configsById.get(formConfigId));
+	}
+
+	@Override
+	public List<StoredFormConfig> listByDataset(String datasetId) {
+		return configsById.values().stream().filter(config -> config.getDatasetId().equals(datasetId)).toList();
+	}
+
+	@Override
+	public boolean deleteById(String formConfigId) {
+		return configsById.remove(formConfigId) != null;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/InMemoryQueryRepository.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/InMemoryQueryRepository.java
new file mode 100644
index 0000000000..f033587241
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/InMemoryQueryRepository.java
@@ -0,0 +1,37 @@
+package com.bakdata.conquery.quarkus.storage;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.bakdata.conquery.quarkus.storage.model.StoredQuery;
+import io.quarkus.arc.properties.IfBuildProperty;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+@IfBuildProperty(name = "conquery.storage.backend", stringValue = "IN_MEMORY", enableIfMissing = true)
+public class InMemoryQueryRepository implements QueryRepository {
+
+	private final Map<String, StoredQuery> queriesById = new ConcurrentHashMap<>();
+
+	@Override
+	public void save(StoredQuery query) {
+		queriesById.put(query.getId(), query);
+	}
+
+	@Override
+	public Optional<StoredQuery> findById(String queryId) {
+		return Optional.ofNullable(queriesById.get(queryId));
+	}
+
+	@Override
+	public List<StoredQuery> listByDataset(String datasetId) {
+		return queriesById.values().stream().filter(query -> query.getDatasetId().equals(datasetId)).toList();
+	}
+
+	@Override
+	public boolean deleteById(String queryId) {
+		return queriesById.remove(queryId) != null;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/NamespaceStorage.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/NamespaceStorage.java
new file mode 100644
index 0000000000..0a09643073
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/NamespaceStorage.java
@@ -0,0 +1,26 @@
+package com.bakdata.conquery.quarkus.storage;
+
+import java.util.List;
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.ids.ConceptId;
+import com.bakdata.conquery.quarkus.ids.StructureNodeId;
+import com.bakdata.conquery.quarkus.ids.TableId;
+
+public interface NamespaceStorage {
+
+	DatasetCatalogRepository.DatasetRecord dataset();
+
+	List<DatasetCatalogRepository.Concept> listConcepts();
+
+	Optional<DatasetCatalogRepository.Concept> findConcept(ConceptId conceptId);
+
+	List<DatasetCatalogRepository.StructureNode> listStructureNodes();
+
+	Optional<DatasetCatalogRepository.StructureNode> findStructureNode(StructureNodeId structureNodeId);
+
+	List<DatasetCatalogRepository.TableRecord> listTables();
+
+	Optional<DatasetCatalogRepository.TableRecord> findTable(TableId tableId);
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/NamespaceStorageRegistry.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/NamespaceStorageRegistry.java
new file mode 100644
index 0000000000..509bd3c906
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/NamespaceStorageRegistry.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.quarkus.storage;
+
+import java.util.List;
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.ids.DatasetId;
+
+public interface NamespaceStorageRegistry {
+
+	List<DatasetCatalogRepository.DatasetRecord> listDatasets();
+
+	Optional<NamespaceStorage> findNamespace(DatasetId datasetId);
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/QueryRepository.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/QueryRepository.java
new file mode 100644
index 0000000000..e179ffa2b7
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/QueryRepository.java
@@ -0,0 +1,17 @@
+package com.bakdata.conquery.quarkus.storage;
+
+import java.util.List;
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.storage.model.StoredQuery;
+
+public interface QueryRepository {
+
+	void save(StoredQuery query);
+
+	Optional<StoredQuery> findById(String queryId);
+
+	List<StoredQuery> listByDataset(String datasetId);
+
+	boolean deleteById(String queryId);
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/RepositoryNamespaceStorageRegistry.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/RepositoryNamespaceStorageRegistry.java
new file mode 100644
index 0000000000..008b4c97b8
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/RepositoryNamespaceStorageRegistry.java
@@ -0,0 +1,97 @@
+package com.bakdata.conquery.quarkus.storage;
+
+import java.util.List;
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.ids.ConceptId;
+import com.bakdata.conquery.quarkus.ids.DatasetId;
+import com.bakdata.conquery.quarkus.ids.StructureNodeId;
+import com.bakdata.conquery.quarkus.ids.TableId;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+
+@ApplicationScoped
+public class RepositoryNamespaceStorageRegistry implements NamespaceStorageRegistry {
+
+	@Inject
+	DatasetCatalogRepository catalogRepository;
+
+	@Override
+	public List<DatasetCatalogRepository.DatasetRecord> listDatasets() {
+		return catalogRepository.listDatasets();
+	}
+
+	@Override
+	public Optional<NamespaceStorage> findNamespace(DatasetId datasetId) {
+		return catalogRepository.findDataset(datasetId).map(dataset -> new RepositoryNamespaceStorage(dataset, catalogRepository));
+	}
+
+	private static final class RepositoryNamespaceStorage implements NamespaceStorage {
+		private final DatasetCatalogRepository.DatasetRecord dataset;
+		private final DatasetCatalogRepository catalogRepository;
+
+		private RepositoryNamespaceStorage(
+				DatasetCatalogRepository.DatasetRecord dataset,
+				DatasetCatalogRepository catalogRepository
+		) {
+			this.dataset = dataset;
+			this.catalogRepository = catalogRepository;
+		}
+
+		@Override
+		public DatasetCatalogRepository.DatasetRecord dataset() {
+			return dataset;
+		}
+
+		@Override
+		public List<DatasetCatalogRepository.Concept> listConcepts() {
+			return catalogRepository.listConceptsForDataset(dataset.id());
+		}
+
+		@Override
+		public Optional<DatasetCatalogRepository.Concept> findConcept(ConceptId conceptId) {
+			if (!belongsToNamespace(conceptId)) {
+				return Optional.empty();
+			}
+			return catalogRepository.findConcept(conceptId);
+		}
+
+		@Override
+		public List<DatasetCatalogRepository.StructureNode> listStructureNodes() {
+			return catalogRepository.listStructureNodesForDataset(dataset.id());
+		}
+
+		@Override
+		public Optional<DatasetCatalogRepository.StructureNode> findStructureNode(StructureNodeId structureNodeId) {
+			if (!belongsToNamespace(structureNodeId)) {
+				return Optional.empty();
+			}
+			return catalogRepository.findStructureNode(structureNodeId);
+		}
+
+		@Override
+		public List<DatasetCatalogRepository.TableRecord> listTables() {
+			return catalogRepository.listTablesForDataset(dataset.id());
+		}
+
+		@Override
+		public Optional<DatasetCatalogRepository.TableRecord> findTable(TableId tableId) {
+			if (!belongsToNamespace(tableId)) {
+				return Optional.empty();
+			}
+			return catalogRepository.findTable(tableId);
+		}
+
+		private boolean belongsToNamespace(ConceptId scopedId) {
+			return dataset.id().equals(scopedId.datasetId());
+		}
+
+		private boolean belongsToNamespace(TableId scopedId) {
+			return dataset.id().equals(scopedId.datasetId());
+		}
+
+		private boolean belongsToNamespace(StructureNodeId scopedId) {
+			return dataset.id().equals(scopedId.datasetId());
+		}
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/meta/InMemoryMetaStorageFacade.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/meta/InMemoryMetaStorageFacade.java
new file mode 100644
index 0000000000..0b96cdd781
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/meta/InMemoryMetaStorageFacade.java
@@ -0,0 +1,28 @@
+package com.bakdata.conquery.quarkus.storage.meta;
+
+import com.bakdata.conquery.quarkus.storage.FormConfigRepository;
+import com.bakdata.conquery.quarkus.storage.QueryRepository;
+import io.quarkus.arc.properties.IfBuildProperty;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+
+@ApplicationScoped
+@IfBuildProperty(name = "conquery.storage.backend", stringValue = "IN_MEMORY", enableIfMissing = true)
+public class InMemoryMetaStorageFacade implements ManagerMetaStorage {
+
+	@Inject
+	QueryRepository queryRepository;
+
+	@Inject
+	FormConfigRepository formConfigRepository;
+
+	@Override
+	public QueryRepository queries() {
+		return queryRepository;
+	}
+
+	@Override
+	public FormConfigRepository formConfigs() {
+		return formConfigRepository;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/meta/ManagerMetaStorage.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/meta/ManagerMetaStorage.java
new file mode 100644
index 0000000000..a3fc0ca3c5
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/meta/ManagerMetaStorage.java
@@ -0,0 +1,11 @@
+package com.bakdata.conquery.quarkus.storage.meta;
+
+import com.bakdata.conquery.quarkus.storage.FormConfigRepository;
+import com.bakdata.conquery.quarkus.storage.QueryRepository;
+
+public interface ManagerMetaStorage {
+
+	QueryRepository queries();
+
+	FormConfigRepository formConfigs();
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/meta/XodusMetaStorageFacade.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/meta/XodusMetaStorageFacade.java
new file mode 100644
index 0000000000..f9d022e3c5
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/meta/XodusMetaStorageFacade.java
@@ -0,0 +1,37 @@
+package com.bakdata.conquery.quarkus.storage.meta;
+
+import com.bakdata.conquery.quarkus.storage.FormConfigRepository;
+import com.bakdata.conquery.quarkus.storage.QueryRepository;
+import io.quarkus.arc.properties.IfBuildProperty;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+
+/**
+ * Integration seam for a future Xodus-backed manager meta storage implementation.
+ */
+@ApplicationScoped
+@IfBuildProperty(name = "conquery.storage.backend", stringValue = "XODUS")
+public class XodusMetaStorageFacade implements ManagerMetaStorage {
+
+	private final QueryRepository queryRepository;
+	private final FormConfigRepository formConfigRepository;
+
+	@Inject
+	public XodusMetaStorageFacade(
+			QueryRepository queryRepository,
+			FormConfigRepository formConfigRepository
+	) {
+		this.queryRepository = queryRepository;
+		this.formConfigRepository = formConfigRepository;
+	}
+
+	@Override
+	public QueryRepository queries() {
+		return queryRepository;
+	}
+
+	@Override
+	public FormConfigRepository formConfigs() {
+		return formConfigRepository;
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/model/StoredFormConfig.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/model/StoredFormConfig.java
new file mode 100644
index 0000000000..4a5b3ee5c2
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/model/StoredFormConfig.java
@@ -0,0 +1,25 @@
+package com.bakdata.conquery.quarkus.storage.model;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+public class StoredFormConfig {
+	private final String id;
+	private final String datasetId;
+	private final String formType;
+	private String label;
+	private List<String> tags;
+	private final String ownerName;
+	private final Instant createdAt;
+	private final boolean system;
+	private List<String> groups;
+	private Map<String, Object> values;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/model/StoredQuery.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/model/StoredQuery.java
new file mode 100644
index 0000000000..c8e3a6b43a
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/model/StoredQuery.java
@@ -0,0 +1,27 @@
+package com.bakdata.conquery.quarkus.storage.model;
+
+import java.time.Instant;
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.api.QueryResource;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+public class StoredQuery {
+	private final String id;
+	private final String datasetId;
+	private String label;
+	private final Instant createdAt;
+	private final String ownerName;
+	private final QueryResource.QueryDefinition definition;
+	private final String secondaryId;
+	private final boolean containsDates;
+	private QueryResource.QueryStatus status;
+	private List<String> tags;
+	private boolean shared;
+	private List<String> groups;
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/xodus/XodusEnvironmentProvider.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/xodus/XodusEnvironmentProvider.java
new file mode 100644
index 0000000000..8296e6eaf4
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/xodus/XodusEnvironmentProvider.java
@@ -0,0 +1,38 @@
+package com.bakdata.conquery.quarkus.storage.xodus;
+
+import java.nio.file.Path;
+
+import com.bakdata.conquery.quarkus.config.StorageRuntimeConfig;
+import io.quarkus.arc.properties.IfBuildProperty;
+import jakarta.annotation.PostConstruct;
+import jakarta.annotation.PreDestroy;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+
+import jetbrains.exodus.env.Environment;
+import jetbrains.exodus.env.Environments;
+import lombok.Getter;
+
+@ApplicationScoped
+@IfBuildProperty(name = "conquery.storage.backend", stringValue = "XODUS")
+public class XodusEnvironmentProvider {
+
+	@Inject
+	StorageRuntimeConfig storageRuntimeConfig;
+
+	@Getter
+    private Environment environment;
+
+	@PostConstruct
+	void init() {
+		environment = Environments.newInstance(Path.of(storageRuntimeConfig.xodus().path()).toFile());
+	}
+
+	@PreDestroy
+	void close() {
+		if (environment != null) {
+			environment.close();
+		}
+	}
+
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/xodus/XodusFormConfigRepository.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/xodus/XodusFormConfigRepository.java
new file mode 100644
index 0000000000..5547dbb598
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/xodus/XodusFormConfigRepository.java
@@ -0,0 +1,97 @@
+package com.bakdata.conquery.quarkus.storage.xodus;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.storage.FormConfigRepository;
+import com.bakdata.conquery.quarkus.storage.model.StoredFormConfig;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.quarkus.arc.properties.IfBuildProperty;
+import jakarta.annotation.PostConstruct;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import jetbrains.exodus.bindings.StringBinding;
+import jetbrains.exodus.env.Cursor;
+import jetbrains.exodus.env.Environment;
+import jetbrains.exodus.env.Store;
+import jetbrains.exodus.env.StoreConfig;
+
+@ApplicationScoped
+@IfBuildProperty(name = "conquery.storage.backend", stringValue = "XODUS")
+public class XodusFormConfigRepository implements FormConfigRepository {
+
+	private static final String STORE_NAME = "quarkus_form_configs";
+
+	@Inject
+	XodusEnvironmentProvider environmentProvider;
+
+	@Inject
+	ObjectMapper objectMapper;
+
+	private Environment environment;
+	private Store store;
+
+	@PostConstruct
+	void init() {
+		environment = environmentProvider.getEnvironment();
+		store = environment.computeInTransaction(tx -> environment.openStore(STORE_NAME, StoreConfig.WITHOUT_DUPLICATES, tx));
+	}
+
+	@Override
+	public void save(StoredFormConfig config) {
+		String payload = serialize(config);
+		environment.executeInTransaction(tx -> store.put(tx, StringBinding.stringToEntry(config.getId()), StringBinding.stringToEntry(payload)));
+	}
+
+	@Override
+	public Optional<StoredFormConfig> findById(String formConfigId) {
+		return environment.computeInReadonlyTransaction(tx -> {
+			var value = store.get(tx, StringBinding.stringToEntry(formConfigId));
+			if (value == null) {
+				return Optional.empty();
+			}
+			return Optional.of(deserialize(StringBinding.entryToString(value), StoredFormConfig.class));
+		});
+	}
+
+	@Override
+	public List<StoredFormConfig> listByDataset(String datasetId) {
+		return environment.computeInReadonlyTransaction(tx -> {
+			List<StoredFormConfig> result = new ArrayList<>();
+			try (Cursor cursor = store.openCursor(tx)) {
+				while (cursor.getNext()) {
+					StoredFormConfig config = deserialize(StringBinding.entryToString(cursor.getValue()), StoredFormConfig.class);
+					if (datasetId.equals(config.getDatasetId())) {
+						result.add(config);
+					}
+				}
+			}
+			return result;
+		});
+	}
+
+	@Override
+	public boolean deleteById(String formConfigId) {
+		return environment.computeInTransaction(tx -> store.delete(tx, StringBinding.stringToEntry(formConfigId)));
+	}
+
+	private String serialize(Object value) {
+		try {
+			return objectMapper.writeValueAsString(value);
+		}
+		catch (IOException e) {
+			throw new IllegalStateException("Failed to serialize value for Xodus store " + STORE_NAME, e);
+		}
+	}
+
+	private <T> T deserialize(String payload, Class<T> type) {
+		try {
+			return objectMapper.readValue(payload, type);
+		}
+		catch (IOException e) {
+			throw new IllegalStateException("Failed to deserialize value from Xodus store " + STORE_NAME, e);
+		}
+	}
+}
diff --git a/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/xodus/XodusQueryRepository.java b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/xodus/XodusQueryRepository.java
new file mode 100644
index 0000000000..167a91f42c
--- /dev/null
+++ b/backend-quarkus/src/main/java/com/bakdata/conquery/quarkus/storage/xodus/XodusQueryRepository.java
@@ -0,0 +1,97 @@
+package com.bakdata.conquery.quarkus.storage.xodus;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.storage.QueryRepository;
+import com.bakdata.conquery.quarkus.storage.model.StoredQuery;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.quarkus.arc.properties.IfBuildProperty;
+import jakarta.annotation.PostConstruct;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import jetbrains.exodus.bindings.StringBinding;
+import jetbrains.exodus.env.Cursor;
+import jetbrains.exodus.env.Environment;
+import jetbrains.exodus.env.Store;
+import jetbrains.exodus.env.StoreConfig;
+
+@ApplicationScoped
+@IfBuildProperty(name = "conquery.storage.backend", stringValue = "XODUS")
+public class XodusQueryRepository implements QueryRepository {
+
+	private static final String STORE_NAME = "quarkus_queries";
+
+	@Inject
+	XodusEnvironmentProvider environmentProvider;
+
+	@Inject
+	ObjectMapper objectMapper;
+
+	private Environment environment;
+	private Store store;
+
+	@PostConstruct
+	void init() {
+		environment = environmentProvider.getEnvironment();
+		store = environment.computeInTransaction(tx -> environment.openStore(STORE_NAME, StoreConfig.WITHOUT_DUPLICATES, tx));
+	}
+
+	@Override
+	public void save(StoredQuery query) {
+		String payload = serialize(query);
+		environment.executeInTransaction(tx -> store.put(tx, StringBinding.stringToEntry(query.getId()), StringBinding.stringToEntry(payload)));
+	}
+
+	@Override
+	public Optional<StoredQuery> findById(String queryId) {
+		return environment.computeInReadonlyTransaction(tx -> {
+			var value = store.get(tx, StringBinding.stringToEntry(queryId));
+			if (value == null) {
+				return Optional.empty();
+			}
+			return Optional.of(deserialize(StringBinding.entryToString(value), StoredQuery.class));
+		});
+	}
+
+	@Override
+	public List<StoredQuery> listByDataset(String datasetId) {
+		return environment.computeInReadonlyTransaction(tx -> {
+			List<StoredQuery> result = new ArrayList<>();
+			try (Cursor cursor = store.openCursor(tx)) {
+				while (cursor.getNext()) {
+					StoredQuery query = deserialize(StringBinding.entryToString(cursor.getValue()), StoredQuery.class);
+					if (datasetId.equals(query.getDatasetId())) {
+						result.add(query);
+					}
+				}
+			}
+			return result;
+		});
+	}
+
+	@Override
+	public boolean deleteById(String queryId) {
+		return environment.computeInTransaction(tx -> store.delete(tx, StringBinding.stringToEntry(queryId)));
+	}
+
+	private String serialize(Object value) {
+		try {
+			return objectMapper.writeValueAsString(value);
+		}
+		catch (IOException e) {
+			throw new IllegalStateException("Failed to serialize value for Xodus store " + STORE_NAME, e);
+		}
+	}
+
+	private <T> T deserialize(String payload, Class<T> type) {
+		try {
+			return objectMapper.readValue(payload, type);
+		}
+		catch (IOException e) {
+			throw new IllegalStateException("Failed to deserialize value from Xodus store " + STORE_NAME, e);
+		}
+	}
+}
diff --git a/backend-quarkus/src/main/resources/application-dev.properties b/backend-quarkus/src/main/resources/application-dev.properties
new file mode 100644
index 0000000000..48c51f9591
--- /dev/null
+++ b/backend-quarkus/src/main/resources/application-dev.properties
@@ -0,0 +1,39 @@
+quarkus.http.cors.enabled=true
+quarkus.http.cors.origins=/.*/
+
+conquery.storage.backend=IN_MEMORY
+
+# Optional startup ingestion of generated dataset metadata folders.
+# conquery.metadata.enabled=true
+# conquery.metadata.root-path=/data/gen
+# conquery.metadata.folders[0]=demo
+
+conquery.frontend.query-upload.ids[0].name=ID
+conquery.frontend.query-upload.ids[0].field=pid
+conquery.frontend.query-upload.ids[0].label=result
+conquery.frontend.query-upload.ids[0].primary-id=true
+conquery.frontend.query-upload.ids[0].print=true
+
+conquery.datasets[0].id=imdb
+conquery.datasets[0].label=IMDb
+conquery.datasets[1].id=empty-set
+conquery.datasets[1].label=Empty Dataset
+
+conquery.concepts[0].id=imdb
+conquery.concepts[0].label=IMDb
+conquery.concepts[0].dataset=imdb
+
+conquery.tables[0].id=imdb.title
+conquery.tables[0].label=Titles
+conquery.tables[0].dataset=imdb
+conquery.tables[0].primary-column=imdb.title.id
+conquery.tables[0].columns[0].id=imdb.title.id
+conquery.tables[0].columns[0].label=Title ID
+conquery.tables[0].columns[0].type=INTEGER
+conquery.tables[0].columns[0].secondary-id=pid
+conquery.tables[0].columns[1].id=imdb.title.name
+conquery.tables[0].columns[1].label=Title
+conquery.tables[0].columns[1].type=STRING
+conquery.tables[0].columns[2].id=imdb.title.release_date
+conquery.tables[0].columns[2].label=Release Date
+conquery.tables[0].columns[2].type=DATE
diff --git a/backend-quarkus/src/main/resources/application-test.properties b/backend-quarkus/src/main/resources/application-test.properties
new file mode 100644
index 0000000000..53a38c9374
--- /dev/null
+++ b/backend-quarkus/src/main/resources/application-test.properties
@@ -0,0 +1,12 @@
+quarkus.log.category."com.bakdata.conquery".level=DEBUG
+
+# Conquery related
+conquery.metadata.enabled=true
+conquery.metadata.root-path=target/test-classes/test-meta-data
+conquery.metadata.folders[0]=imdb
+conquery.metadata.folders[1]=empty_set
+
+conquery.entity-preview.all[0].name=all:entities
+conquery.entity-preview.all[0].label=Entities
+conquery.entity-preview.default[0].name=default:entities
+conquery.entity-preview.default[0].label=Entities
diff --git a/backend-quarkus/src/main/resources/application.properties b/backend-quarkus/src/main/resources/application.properties
new file mode 100644
index 0000000000..1872e12094
--- /dev/null
+++ b/backend-quarkus/src/main/resources/application.properties
@@ -0,0 +1,14 @@
+quarkus.http.port=8090
+quarkus.http.root-path=/
+quarkus.smallrye-openapi.path=/q/openapi
+quarkus.swagger-ui.always-include=true
+quarkus.swagger-ui.path=/q/swagger-ui
+quarkus.package.jar.type=mutable-jar
+quarkus.package.jar.user-providers-directory=providers
+
+# Build-time selection of persistent manager meta storage backend: IN_MEMORY or XODUS.
+# Dataset definitions are always loaded from configured metadata folders into memory at startup.
+conquery.storage.backend=IN_MEMORY
+
+# SQL execution is activated explicitly after named Quarkus datasources have been configured.
+conquery.sql.enabled=false
diff --git a/backend-quarkus/src/main/resources/forms/export_form.frontend_conf.json b/backend-quarkus/src/main/resources/forms/export_form.frontend_conf.json
new file mode 100644
index 0000000000..247d105569
--- /dev/null
+++ b/backend-quarkus/src/main/resources/forms/export_form.frontend_conf.json
@@ -0,0 +1,40 @@
+{
+  "type": "EXPORT_FORM",
+  "title": {
+    "de": "Export Formular",
+    "en": "Export Form"
+  },
+  "description": {
+    "de": "Beispiel-Formular fuer die Quarkus Migration.",
+    "en": "Example form for the Quarkus migration."
+  },
+  "fields": [
+    {
+      "type": "HEADLINE",
+      "label": {
+        "de": "Ergebnis",
+        "en": "Result"
+      }
+    },
+    {
+      "name": "resultGroup",
+      "type": "RESULT_GROUP",
+      "label": {
+        "de": "Ergebnisgruppe",
+        "en": "Result Group"
+      },
+      "dropzoneLabel": {
+        "de": "Ziehe eine vorherige Abfrage hierher",
+        "en": "Drop a previous query here"
+      }
+    },
+    {
+      "name": "dataset",
+      "type": "DATASET_SELECT",
+      "label": {
+        "de": "Datensatz",
+        "en": "Dataset"
+      }
+    }
+  ]
+}
diff --git a/backend-quarkus/src/main/resources/forms/table_export_form.frontend_conf.json b/backend-quarkus/src/main/resources/forms/table_export_form.frontend_conf.json
new file mode 100644
index 0000000000..5e5f1d3abc
--- /dev/null
+++ b/backend-quarkus/src/main/resources/forms/table_export_form.frontend_conf.json
@@ -0,0 +1,40 @@
+{
+  "type": "FULL_EXPORT_FORM",
+  "title": {
+    "de": "Tabellenexport",
+    "en": "Table Export"
+  },
+  "description": {
+    "de": "Minimale Konfiguration fuer den Formular-Tab.",
+    "en": "Minimal configuration for the forms tab."
+  },
+  "fields": [
+    {
+      "type": "HEADLINE",
+      "label": {
+        "de": "Zeitraum",
+        "en": "Date Range"
+      }
+    },
+    {
+      "name": "dateRange",
+      "type": "DATE_RANGE",
+      "label": {
+        "de": "Zeitraum",
+        "en": "Date Range"
+      }
+    },
+    {
+      "name": "resultGroup",
+      "type": "RESULT_GROUP",
+      "label": {
+        "de": "Ergebnisgruppe",
+        "en": "Result Group"
+      },
+      "dropzoneLabel": {
+        "de": "Ziehe eine vorherige Abfrage hierher",
+        "en": "Drop a previous query here"
+      }
+    }
+  ]
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/ConceptResourceTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/ConceptResourceTest.java
new file mode 100644
index 0000000000..cf8c210f60
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/ConceptResourceTest.java
@@ -0,0 +1,58 @@
+package com.bakdata.conquery.quarkus.api;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.nullValue;
+
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.Test;
+
+@QuarkusTest
+class ConceptResourceTest {
+
+	@Test
+	void conceptEndpointReturnsConceptMap() {
+		given()
+				.when().get("/api/concepts/imdb")
+				.then()
+				.statusCode(200)
+				.body("imdb.label", equalTo("IMDb"))
+				.body("imdb.active", nullValue())
+				.body("imdb.parent", nullValue())
+				.body("imdb.detailsAvailable", nullValue())
+				.body("imdb.codeListResolvable", equalTo(false))
+				.body("imdb.additionalInfos[0].key", equalTo("Source"))
+				.body("imdb.additionalInfos[0].value", equalTo("IMDb test metadata"))
+				.body("imdb.excludeFromTimeAggregation", equalTo(false))
+				.body("imdb.tables.size()", equalTo(1))
+				.body("imdb.tables[0].id", equalTo("imdb.title"))
+				.body("imdb.tables[0].default", equalTo(true))
+				.body("imdb.tables[0].dateColumn.tooltip", equalTo("Choose the release date"))
+				.body("imdb.tables[0].dateColumn.defaultValue", equalTo("imdb.titles.Release_date"))
+				.body("imdb.tables[0].dateColumn.value", nullValue())
+				.body("imdb.tables[0].dateColumn.options[0].value", equalTo("imdb.titles.Release_date"))
+				.body("imdb.tables[0].dateColumn.options[0].label", equalTo("Release date"))
+				.body("imdb.tables[0].selects[0].id", equalTo("imdb.titles.Title"))
+				.body("imdb.tables[0].selects[0].label", equalTo("Title"))
+				.body("imdb.tables[0].selects[0].default", equalTo(true))
+				.body("imdb.tables[0].selects[0].resultType.type", equalTo("STRING"))
+				.body("imdb.selects[0].id", equalTo("imdb.exists"))
+				.body("imdb.selects[0].label", equalTo("Exists"))
+				.body("imdb.selects[0].default", equalTo(true))
+				.body("imdb.selects[0].resultType.type", equalTo("BOOLEAN"))
+				.body("'imdb.movie'.parent", equalTo("imdb"))
+				.body("'imdb.movie'.active", nullValue())
+				.body("'imdb.movie'.detailsAvailable", nullValue())
+				.body("'imdb.movie'.codeListResolvable", equalTo(false))
+				.body("'imdb.movie'.additionalInfos[0].key", equalTo("Kind"))
+				.body("'imdb.movie'.excludeFromTimeAggregation", nullValue());
+	}
+
+	@Test
+	void conceptEndpointReturns404ForUnknownConcept() {
+		given()
+				.when().get("/api/concepts/unknown")
+				.then()
+				.statusCode(404);
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/DatasetsResourceTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/DatasetsResourceTest.java
new file mode 100644
index 0000000000..2ec3c7bbd2
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/DatasetsResourceTest.java
@@ -0,0 +1,195 @@
+package com.bakdata.conquery.quarkus.api;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.greaterThanOrEqualTo;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.hamcrest.Matchers.nullValue;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.Test;
+
+@QuarkusTest
+class DatasetsResourceTest {
+
+	@Test
+	void datasetsEndpointRespondsWithConfiguredDatasets() {
+		given()
+				.when().get("/api/datasets")
+				.then()
+				.statusCode(200)
+				.body("size()", greaterThanOrEqualTo(1))
+				.body("[0].id", equalTo("imdb"))
+				.body("[0].label", equalTo("IMDb"));
+	}
+
+	@Test
+	void entityPreviewEndpointRespondsWithConfiguredDefaults() {
+		given()
+				.when().get("/api/datasets/imdb/entity-preview")
+				.then()
+				.statusCode(200)
+				.body("all[0].name", equalTo("all:entities"))
+				.body("all[0].label", equalTo("Entities"))
+				.body("default[0].name", equalTo("default:entities"))
+				.body("default[0].label", equalTo("Entities"))
+				.body("searchConcept", nullValue())
+				.body("searchFilters.size()", equalTo(0));
+	}
+
+	@Test
+	void entityPreviewEndpointReturns404ForUnknownDataset() {
+		given()
+				.when().get("/api/datasets/unknown/entity-preview")
+				.then()
+				.statusCode(404);
+	}
+
+	@Test
+	void conceptsEndpointRespondsWithFrontendCompatibleShape() {
+		given()
+				.when().get("/api/datasets/imdb/concepts")
+				.then()
+				.statusCode(200)
+				.body("secondaryIds.size()", equalTo(0))
+				.body("concepts.imdb.label", equalTo("IMDb"))
+				.body("concepts.imdb.active", equalTo(true))
+				.body("concepts.imdb.parent", equalTo("imdb.catalog.Movies"))
+				.body("concepts.imdb.detailsAvailable", equalTo(true))
+				.body("concepts.imdb.codeListResolvable", equalTo(true))
+				.body("concepts.imdb.additionalInfos[0].key", equalTo("Source"))
+				.body("concepts.imdb.excludeFromTimeAggregation", equalTo(false))
+				.body("concepts.imdb.children", equalTo(java.util.List.of("imdb.movie")))
+				.body("concepts.imdb.tables[0].default", equalTo(true))
+				.body("concepts.imdb.tables[0].connectorId", equalTo("imdb.titles"))
+				.body("concepts.imdb.tables[0].dateColumn.defaultValue", equalTo("imdb.titles.Release_date"))
+				.body("concepts.imdb.tables[0].filters[0].id", equalTo("imdb.titles.release_age"))
+				.body("concepts.imdb.tables[0].selects[0].id", equalTo("imdb.titles.Title"))
+				.body("concepts.imdb.tables[0].selects[0].default", equalTo(true))
+				.body("concepts.imdb.tables[0].selects[0].resultType.type", equalTo("STRING"))
+				.body("concepts.imdb.selects[0].id", equalTo("imdb.exists"))
+				.body("concepts.imdb.selects[0].default", equalTo(true))
+				.body("concepts.imdb.selects[0].resultType.type", equalTo("BOOLEAN"))
+				.body("concepts.'imdb.catalog'.label", equalTo("Catalog"))
+				.body("concepts.'imdb.catalog'.active", equalTo(false))
+				.body("concepts.'imdb.catalog'.detailsAvailable", equalTo(false))
+				.body("concepts.'imdb.catalog'.children", equalTo(java.util.List.of("imdb.catalog.Movies")))
+				.body("concepts.'imdb.catalog.Movies'.parent", equalTo("imdb.catalog"))
+				.body("concepts.'imdb.catalog.Movies'.children", equalTo(java.util.List.of("imdb")))
+				.body("concepts.'imdb.empty'", nullValue());
+	}
+
+	@Test
+	void conceptsEndpointPreservesStructureNodeJsonOrder() {
+		Map<String, Object> concepts = given()
+				.when().get("/api/datasets/imdb/concepts")
+				.then()
+				.statusCode(200)
+				.extract().path("concepts");
+
+		org.hamcrest.MatcherAssert.assertThat(
+				new ArrayList<>(concepts.keySet()),
+				equalTo(List.of("imdb", "imdb.catalog", "imdb.catalog.Movies"))
+		);
+	}
+
+	@Test
+	void conceptsEndpointReturns404ForUnknownDataset() {
+		given()
+				.when().get("/api/datasets/unknown/concepts")
+				.then()
+				.statusCode(404);
+	}
+
+	@Test
+	void formQueriesEndpointReturnsForms() {
+		given()
+				.when().get("/api/datasets/imdb/form-queries")
+				.then()
+				.statusCode(200)
+				.body("size()", greaterThanOrEqualTo(1))
+				.body("[0].type", equalTo("EXPORT_FORM"))
+				.body("[0].fields.size()", greaterThanOrEqualTo(1));
+	}
+
+	@Test
+	void formQueriesEndpointReturns404ForUnknownDataset() {
+		given()
+				.when().get("/api/datasets/unknown/form-queries")
+				.then()
+				.statusCode(404);
+	}
+
+	@Test
+	void queriesEndpointReturnsEmptyList() {
+		given()
+				.when().get("/api/datasets/imdb/queries")
+				.then()
+				.statusCode(200)
+				.body("size()", equalTo(0));
+	}
+
+	@Test
+	void queriesEndpointReturns404ForUnknownDataset() {
+		given()
+				.when().get("/api/datasets/unknown/queries")
+				.then()
+				.statusCode(404);
+	}
+
+	@Test
+	void postQueriesEndpointReturnsCreatedQueryId() {
+		given()
+				.contentType("application/json")
+				.body("{\"type\":\"CONCEPT_QUERY\"}")
+				.when().post("/api/datasets/imdb/queries")
+				.then()
+				.statusCode(200)
+				.body("id", notNullValue());
+	}
+
+	@Test
+	void postQueriesEndpointReturns404ForUnknownDataset() {
+		given()
+				.contentType("application/json")
+				.body("{\"type\":\"CONCEPT_QUERY\"}")
+				.when().post("/api/datasets/unknown/queries")
+				.then()
+				.statusCode(404);
+	}
+
+	@Test
+	void resolveEntitiesEndpointIsMarkedAsNotImplemented() {
+		given()
+				.contentType("application/json")
+				.body("""
+						[{
+						  "filter":"imdb.titles.release_age",
+						  "type":"MULTI_SELECT",
+						  "value":["one","two"]
+						}]
+						""")
+				.when().post("/api/datasets/imdb/queries/resolve-entities")
+				.then().statusCode(501);
+	}
+
+	@Test
+	void entityHistoryEndpointIsMarkedAsNotImplemented() {
+		given()
+				.contentType("application/json")
+				.body("""
+						{
+						  "idKind":"ID",
+						  "entityId":"one",
+						  "time":{"min":"2020-01-01","max":"2020-12-31"},
+						  "sources":["imdb.titles"]
+						}
+						""")
+				.when().post("/api/datasets/imdb/queries/entity")
+				.then().statusCode(501);
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/MeResourceTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/MeResourceTest.java
new file mode 100644
index 0000000000..5e7fde410b
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/MeResourceTest.java
@@ -0,0 +1,38 @@
+package com.bakdata.conquery.quarkus.api;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.notNullValue;
+
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.security.TestSecurity;
+import org.junit.jupiter.api.Test;
+
+@QuarkusTest
+class MeResourceTest {
+
+	@Test
+	void meEndpointRespondsWithExpectedShape() {
+		given()
+				.when().get("/api/me")
+				.then()
+				.statusCode(200)
+				.body("userName", equalTo("anonymous"))
+				.body("hideLogoutButton", equalTo(true))
+				.body("datasetAbilities", notNullValue())
+				.body("groups", notNullValue());
+	}
+
+	@Test
+	@TestSecurity(user = "testUser")
+	void authenticatedMeEndpointRespondsWithExpectedShape() {
+		given()
+				.when().get("/api/me")
+				.then()
+				.statusCode(200)
+				.body("userName", equalTo("testUser"))
+				.body("hideLogoutButton", equalTo(true))
+				.body("datasetAbilities", notNullValue())
+				.body("groups", notNullValue());
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/PingResourceTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/PingResourceTest.java
new file mode 100644
index 0000000000..e9bbd7e756
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/PingResourceTest.java
@@ -0,0 +1,21 @@
+package com.bakdata.conquery.quarkus.api;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.equalTo;
+
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.Test;
+
+@QuarkusTest
+class PingResourceTest {
+
+	@Test
+	void pingEndpointResponds() {
+		given()
+				.when().get("/api/ping")
+				.then()
+				.statusCode(200)
+				.body("status", equalTo("ok"))
+				.body("service", equalTo("conquery-backend-quarkus"));
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/QueryResourceTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/QueryResourceTest.java
new file mode 100644
index 0000000000..a51176e577
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/QueryResourceTest.java
@@ -0,0 +1,102 @@
+package com.bakdata.conquery.quarkus.api;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.notNullValue;
+
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.Test;
+
+@QuarkusTest
+class QueryResourceTest {
+
+	@Test
+	void queryEndpointRespondsWithNewStatus() {
+		String queryId = createQuery();
+
+		given()
+				.when().get("/api/queries/{queryId}", queryId)
+				.then()
+				.statusCode(200)
+				.body("id", equalTo(queryId))
+				.body("label", equalTo("Query " + queryId))
+				.body("status", equalTo("NEW"))
+				.body("query.type", equalTo("CONCEPT_QUERY"))
+				.body("createdAt", notNullValue());
+	}
+
+	@Test
+	void cancelQueryEndpointResponds() {
+		String queryId = createQuery();
+
+		given()
+				.when().post("/api/queries/{queryId}/cancel", queryId)
+				.then()
+				.statusCode(204);
+	}
+
+	@Test
+	void queryEndpointRoundTripsTypedFilterValues() {
+		String queryId = given()
+				.contentType("application/json")
+				.body("""
+						{
+						  "type":"CONCEPT_QUERY",
+						  "root":{
+						    "type":"CONCEPT",
+						    "tables":[{
+						      "id":"imdb.titles",
+						      "filters":[{
+						        "filter":"imdb.titles.release_age",
+						        "type":"INTEGER_RANGE",
+						        "value":{"min":1,"max":10}
+						      }]
+						    }]
+						  }
+						}
+						""")
+				.when().post("/api/datasets/imdb/queries")
+				.then().statusCode(200)
+				.extract().path("id");
+
+		given()
+				.when().get("/api/queries/{queryId}", queryId)
+				.then().statusCode(200)
+				.body("query.root.tables[0].filters[0].type", equalTo("INTEGER_RANGE"))
+				.body("query.root.tables[0].filters[0].filter", equalTo("imdb.titles.release_age"))
+				.body("query.root.tables[0].filters[0].value.min", equalTo(1))
+				.body("query.root.tables[0].filters[0].value.max", equalTo(10));
+	}
+
+	@Test
+	void queryEndpointRejectsUnknownFilterValueType() {
+		given()
+				.contentType("application/json")
+				.body("""
+						{
+						  "type":"CONCEPT_QUERY",
+						  "root":{
+						    "type":"CONCEPT",
+						    "tables":[{"filters":[{
+						      "filter":"imdb.titles.release_age",
+						      "type":"EXTERNAL_VALUE",
+						      "value":1
+						    }]}]
+						  }
+						}
+						""")
+				.when().post("/api/datasets/imdb/queries")
+				.then().statusCode(400);
+	}
+
+	private String createQuery() {
+		return given()
+				.contentType("application/json")
+				.body("{\"type\":\"CONCEPT_QUERY\"}")
+				.when().post("/api/datasets/imdb/queries")
+				.then()
+				.statusCode(200)
+				.body("id", notNullValue())
+				.extract().path("id");
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/config/FrontendConfigResourceTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/config/FrontendConfigResourceTest.java
new file mode 100644
index 0000000000..356f777f14
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/api/config/FrontendConfigResourceTest.java
@@ -0,0 +1,26 @@
+package com.bakdata.conquery.quarkus.api.config;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.notNullValue;
+
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.Test;
+
+@QuarkusTest
+class FrontendConfigResourceTest {
+
+	@Test
+	void frontendConfigEndpointResponds() {
+		given()
+				.when().get("/api/config/frontend")
+				.then()
+				.statusCode(200)
+				.body("currency.unit", notNullValue())
+				.body("currency.decimalScale", notNullValue())
+				.body("queryUpload.table", equalTo("entities"))
+				.body("queryUpload.ids[0].name", equalTo("ID"))
+				.body("versions[0].name", equalTo("Backend"))
+				.body("observationPeriodStart", notNullValue());
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/conditions/ConceptConditionDeserializationTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/conditions/ConceptConditionDeserializationTest.java
new file mode 100644
index 0000000000..5d10940342
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/conditions/ConceptConditionDeserializationTest.java
@@ -0,0 +1,52 @@
+package com.bakdata.conquery.quarkus.concepts.conditions;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.AndConceptCondition;
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.EqualConceptCondition;
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.NotConceptCondition;
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.PresentConceptCondition;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.quarkus.test.junit.QuarkusTest;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.Test;
+
+@QuarkusTest
+class ConceptConditionDeserializationTest {
+
+	@Inject
+	ObjectMapper objectMapper;
+
+	@Test
+	void deserializesNestedRegisteredConditions() throws Exception {
+		ConceptCondition condition = objectMapper.readValue("""
+				{
+				  "type":"AND",
+				  "conditions":[
+				    {"type":"EQUAL","values":["A00","A01"]},
+				    {"type":"NOT","condition":{"type":"PRESENT","column":"deleted_at"}}
+				  ]
+				}
+				""", ConceptCondition.class);
+
+		AndConceptCondition and = assertInstanceOf(AndConceptCondition.class, condition);
+		EqualConceptCondition equal = assertInstanceOf(EqualConceptCondition.class, and.getConditions().getFirst());
+		assertEquals("EQUAL", equal.getType());
+		assertEquals(java.util.List.of("A00", "A01"), equal.getValues());
+		NotConceptCondition not = assertInstanceOf(NotConceptCondition.class, and.getConditions().get(1));
+		PresentConceptCondition present = assertInstanceOf(PresentConceptCondition.class, not.getCondition());
+		assertEquals("deleted_at", present.getColumn());
+	}
+
+	@Test
+	void keepsUnknownTypeAsExplicitFallbackModel() throws Exception {
+		ConceptCondition condition = objectMapper.readValue("""
+				{"type":"EXTERNAL_CONDITION","expression":"value != null"}
+				""", ConceptCondition.class);
+
+		UnknownConceptCondition unknown = assertInstanceOf(UnknownConceptCondition.class, condition);
+		assertEquals("EXTERNAL_CONDITION", unknown.getType());
+		assertEquals("value != null", unknown.properties().get("expression"));
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/filters/BackendFilterConversionContextTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/filters/BackendFilterConversionContextTest.java
new file mode 100644
index 0000000000..7d18347746
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/filters/BackendFilterConversionContextTest.java
@@ -0,0 +1,40 @@
+package com.bakdata.conquery.quarkus.concepts.filters;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.quarkus.ids.ConceptId;
+import com.bakdata.conquery.quarkus.ids.ConnectorId;
+import com.bakdata.conquery.quarkus.ids.DatasetId;
+import com.bakdata.conquery.quarkus.ids.TableId;
+import com.bakdata.conquery.models.datasets.ColumnDescriptor;
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import org.junit.jupiter.api.Test;
+
+class BackendFilterConversionContextTest {
+
+	@Test
+	void preservesDateRangeColumnTypeForPlugins() {
+		DatasetId datasetId = new DatasetId("demo");
+		TableId tableId = new TableId(datasetId, "events");
+		ColumnId columnId = new ColumnId(tableId, "validity");
+		DatasetCatalogRepository.TableRecord table = new DatasetCatalogRepository.TableRecord(
+				tableId,
+				"Events",
+				List.of(new DatasetCatalogRepository.ColumnRecord(columnId, "Validity", ColumnType.DATE_RANGE, null)),
+				columnId
+		);
+		ConnectorId connectorId = new ConnectorId(new ConceptId(datasetId, List.of("events")), "events");
+		BackendFilterConversionContext context = new BackendFilterConversionContext(
+				connectorId,
+				tableId,
+				table,
+				(idType, fallbackContext, fallbackValue, sanitized) -> { }
+		);
+
+		assertEquals(new ColumnDescriptor("validity", ColumnType.DATE_RANGE), context.requireColumn("validity"));
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/filters/FilterDefinitionDeserializationTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/filters/FilterDefinitionDeserializationTest.java
new file mode 100644
index 0000000000..4060f65f01
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/filters/FilterDefinitionDeserializationTest.java
@@ -0,0 +1,57 @@
+package com.bakdata.conquery.quarkus.concepts.filters;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.CountFilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.bakdata.conquery.quarkus.plugin.api.filters.UnknownFilterDefinition;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.quarkus.test.junit.QuarkusTest;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.Test;
+
+@QuarkusTest
+class FilterDefinitionDeserializationTest {
+
+	@Inject
+	ObjectMapper objectMapper;
+
+	@Test
+	void deserializesKnownTypeToRegisteredModel() throws Exception {
+		FilterDefinition definition = objectMapper.readValue("""
+				{"type":"COUNT","name":"events","column":"event_id","distinctByColumn":"person_id","legacyProperty":true}
+				""", FilterDefinition.class);
+
+		CountFilterDefinition count = assertInstanceOf(CountFilterDefinition.class, definition);
+		assertEquals("events", count.getName());
+		assertEquals("event_id", count.getColumn());
+		assertEquals(List.of("person_id"), count.getDistinctByColumn());
+	}
+
+	@Test
+	void keepsUnknownTypeAsExplicitFallbackModel() throws Exception {
+		FilterDefinition definition = objectMapper.readValue("""
+				{"type":"EXTENSION_FILTER","column":"event_id"}
+				""", FilterDefinition.class);
+
+		UnknownFilterDefinition unknown = assertInstanceOf(UnknownFilterDefinition.class, definition);
+		assertEquals("EXTENSION_FILTER", unknown.getType());
+		assertEquals("event_id", unknown.properties().get("column"));
+	}
+
+	@Test
+	void acceptsSingleFilterWhereListIsExpected() throws Exception {
+		FilterList payload = objectMapper.readValue("""
+				{"filters":{"type":"NUMBER","column":"amount"}}
+				""", FilterList.class);
+
+		assertEquals(1, payload.filters().size());
+		assertEquals("NUMBER", payload.filters().getFirst().getType());
+	}
+
+	private record FilterList(List<FilterDefinition> filters) {
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/filters/FilterDefinitionProviderValueTypesTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/filters/FilterDefinitionProviderValueTypesTest.java
new file mode 100644
index 0000000000..5a80e8ea52
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/filters/FilterDefinitionProviderValueTypesTest.java
@@ -0,0 +1,49 @@
+package com.bakdata.conquery.quarkus.concepts.filters;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Map;
+import java.util.Set;
+
+import com.bakdata.conquery.quarkus.concepts.filters.providers.BigMultiSelectFilterProvider;
+import com.bakdata.conquery.quarkus.concepts.filters.providers.CategoryMaxSumFilterProvider;
+import com.bakdata.conquery.quarkus.concepts.filters.providers.CountFilterProvider;
+import com.bakdata.conquery.quarkus.concepts.filters.providers.CountQuartersFilterProvider;
+import com.bakdata.conquery.quarkus.concepts.filters.providers.DateDistanceFilterProvider;
+import com.bakdata.conquery.quarkus.concepts.filters.providers.DurationSumFilterProvider;
+import com.bakdata.conquery.quarkus.concepts.filters.providers.FlagsFilterProvider;
+import com.bakdata.conquery.quarkus.concepts.filters.providers.NumberFilterProvider;
+import com.bakdata.conquery.quarkus.concepts.filters.providers.PrefixTextFilterProvider;
+import com.bakdata.conquery.quarkus.concepts.filters.providers.QuartersInYearFilterProvider;
+import com.bakdata.conquery.quarkus.concepts.filters.providers.SelectFilterProvider;
+import com.bakdata.conquery.quarkus.concepts.filters.providers.SingleSelectFilterProvider;
+import com.bakdata.conquery.quarkus.concepts.filters.providers.SumFilterProvider;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinitionProvider;
+import org.junit.jupiter.api.Test;
+
+class FilterDefinitionProviderValueTypesTest {
+
+	private static final Set<String> INTEGER_RANGE = Set.of("INTEGER_RANGE");
+	private static final Set<String> NUMERIC_RANGES = Set.of("INTEGER_RANGE", "MONEY_RANGE", "REAL_RANGE");
+
+	@Test
+	void declaresAcceptedFilterValueTypesForEveryBuiltInProvider() {
+		Map<FilterDefinitionProvider<?>, Set<String>> expected = Map.ofEntries(
+				Map.entry(new BigMultiSelectFilterProvider(), Set.of("BIG_MULTI_SELECT")),
+				Map.entry(new CategoryMaxSumFilterProvider(), NUMERIC_RANGES),
+				Map.entry(new CountFilterProvider(), INTEGER_RANGE),
+				Map.entry(new CountQuartersFilterProvider(), INTEGER_RANGE),
+				Map.entry(new DateDistanceFilterProvider(), INTEGER_RANGE),
+				Map.entry(new DurationSumFilterProvider(), INTEGER_RANGE),
+				Map.entry(new FlagsFilterProvider(), Set.of("MULTI_SELECT")),
+				Map.entry(new NumberFilterProvider(), NUMERIC_RANGES),
+				Map.entry(new PrefixTextFilterProvider(), Set.of("STRING")),
+				Map.entry(new QuartersInYearFilterProvider(), INTEGER_RANGE),
+				Map.entry(new SelectFilterProvider(), Set.of("MULTI_SELECT", "BIG_MULTI_SELECT")),
+				Map.entry(new SingleSelectFilterProvider(), Set.of("SELECT")),
+				Map.entry(new SumFilterProvider(), NUMERIC_RANGES)
+		);
+
+		expected.forEach((provider, valueTypes) -> assertEquals(valueTypes, provider.acceptedValueTypes(), provider.type()));
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/filters/values/FilterValueDeserializationTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/filters/values/FilterValueDeserializationTest.java
new file mode 100644
index 0000000000..9957083c30
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/filters/values/FilterValueDeserializationTest.java
@@ -0,0 +1,87 @@
+package com.bakdata.conquery.quarkus.concepts.filters.values;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+
+import java.math.BigDecimal;
+import java.util.Set;
+
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.MultiSelectFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.filters.values.definitions.*;
+import com.bakdata.conquery.quarkus.ids.FilterId;
+import com.bakdata.conquery.quarkus.plugin.api.filters.FilterDefinition;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.quarkus.test.junit.QuarkusTest;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+@QuarkusTest
+class FilterValueDeserializationTest {
+
+	@Inject
+	ObjectMapper objectMapper;
+
+	@ParameterizedTest
+	@ValueSource(strings = {"MULTI_SELECT", "BIG_MULTI_SELECT", "SELECT", "STRING", "INTEGER", "INTEGER_RANGE", "MONEY_RANGE", "REAL", "REAL_RANGE"})
+	void deserializesEveryRegisteredType(String type) throws Exception {
+		String value = switch (type) {
+			case "MULTI_SELECT", "BIG_MULTI_SELECT" -> "[\"one\"]";
+			case "SELECT", "STRING" -> "\"one\"";
+			case "INTEGER" -> "42";
+			case "INTEGER_RANGE", "MONEY_RANGE" -> "{\"min\":1,\"max\":2}";
+			case "REAL" -> "1.5";
+			case "REAL_RANGE" -> "{\"min\":1.5,\"max\":2.5}";
+			default -> throw new IllegalArgumentException(type);
+		};
+		FilterValue filterValue = read(type, value);
+
+		assertEquals(expectedClass(type), filterValue.getClass());
+		assertEquals(FilterId.parse("demo.concept.connector.filter"), filterValue.filter());
+		assertEquals(type, objectMapper.valueToTree(filterValue).path("type").asText());
+	}
+
+	@Test
+	void keepsFilterDefinitionAndFilterValueSelectDiscriminatorsIndependent() throws Exception {
+		FilterDefinition definition = objectMapper.readValue("""
+				{"type":"SELECT","column":"code"}
+				""", FilterDefinition.class);
+		FilterValue value = read("SELECT", "\"one\"");
+
+		assertInstanceOf(MultiSelectFilterDefinition.class, definition);
+		SelectFilterValue selectValue = assertInstanceOf(SelectFilterValue.class, value);
+		assertEquals("one", selectValue.value());
+	}
+
+	@Test
+	void usesConcreteCollectionNumberAndRangeTypes() throws Exception {
+		MultiSelectFilterValue multi = assertInstanceOf(MultiSelectFilterValue.class, read("MULTI_SELECT", "[\"one\",\"two\"]"));
+		RealFilterValue real = assertInstanceOf(RealFilterValue.class, read("REAL", "1.25"));
+		IntegerRangeFilterValue range = assertInstanceOf(IntegerRangeFilterValue.class, read("INTEGER_RANGE", "{\"min\":1,\"max\":4}"));
+
+		assertEquals(Set.of("one", "two"), multi.value());
+		assertEquals(new BigDecimal("1.25"), real.value());
+		assertEquals(1L, range.value().min());
+		assertEquals(4L, range.value().max());
+	}
+
+	private FilterValue read(String type, String value) throws Exception {
+		return objectMapper.readValue("{\"type\":\"" + type + "\",\"filter\":\"demo.concept.connector.filter\",\"value\":" + value + "}", FilterValue.class);
+	}
+
+	private Class<? extends FilterValue> expectedClass(String type) {
+		return switch (type) {
+			case "MULTI_SELECT" -> MultiSelectFilterValue.class;
+			case "BIG_MULTI_SELECT" -> BigMultiSelectFilterValue.class;
+			case "SELECT" -> SelectFilterValue.class;
+			case "STRING" -> StringFilterValue.class;
+			case "INTEGER" -> IntegerFilterValue.class;
+			case "INTEGER_RANGE" -> IntegerRangeFilterValue.class;
+			case "MONEY_RANGE" -> MoneyRangeFilterValue.class;
+			case "REAL" -> RealFilterValue.class;
+			case "REAL_RANGE" -> RealRangeFilterValue.class;
+			default -> throw new IllegalArgumentException(type);
+		};
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/selects/SelectDefinitionDeserializationTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/selects/SelectDefinitionDeserializationTest.java
new file mode 100644
index 0000000000..37e84aa0ee
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/selects/SelectDefinitionDeserializationTest.java
@@ -0,0 +1,65 @@
+package com.bakdata.conquery.quarkus.concepts.selects;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.CountSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.SelectId;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.quarkus.test.junit.QuarkusTest;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+@QuarkusTest
+class SelectDefinitionDeserializationTest {
+
+	@Inject
+	ObjectMapper objectMapper;
+
+	@ParameterizedTest
+	@ValueSource(strings = {"DISTINCT", "FIRST", "LAST", "RANDOM", "COUNT", "COUNT_QUARTERS", "DATE_DISTANCE", "DATE_UNION", "DURATION_SUM", "FLAGS", "PREFIX", "QUARTERS_IN_YEAR", "SUM"})
+	void deserializesEveryRegisteredType(String type) throws Exception {
+		SelectDefinition definition = objectMapper.readValue("{\"type\":\"" + type + "\"}", SelectDefinition.class);
+
+		assertFalse(definition instanceof UnknownSelectDefinition, type);
+		assertEquals(type, definition.getType());
+	}
+
+	@Test
+	void acceptsScalarsWhereSelectAndNestedColumnListsAreExpected() throws Exception {
+		SelectList payload = objectMapper.readValue("""
+				{"selects":{"type":"COUNT","column":"event_id","distinctByColumn":"person_id"}}
+				""", SelectList.class);
+
+		CountSelectDefinition count = assertInstanceOf(CountSelectDefinition.class, payload.selects().getFirst());
+		assertEquals(List.of("person_id"), count.getDistinctByColumn());
+	}
+
+	@Test
+	void keepsUnknownTypeAsExplicitFallbackModel() throws Exception {
+		SelectDefinition definition = objectMapper.readValue("""
+				{"type":"EXTENSION_SELECT","column":"event_id"}
+				""", SelectDefinition.class);
+
+		UnknownSelectDefinition unknown = assertInstanceOf(UnknownSelectDefinition.class, definition);
+		assertEquals("event_id", unknown.properties().get("column"));
+	}
+
+	@Test
+	void serializesTypedSelectIdAsString() throws Exception {
+		SelectId id = SelectId.parse("demo.concept.connector.select");
+
+		assertEquals("demo.concept.connector.select", id.toString());
+		assertEquals("\"demo.concept.connector.select\"", objectMapper.writeValueAsString(id));
+		assertEquals(id, objectMapper.readValue("\"demo.concept.connector.select\"", SelectId.class));
+		assertEquals("demo", id.datasetId().toString());
+	}
+
+	private record SelectList(List<SelectDefinition> selects) {
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectDefinitionDeserializationTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectDefinitionDeserializationTest.java
new file mode 100644
index 0000000000..bdf87e6c6b
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/concepts/selects/concept/ConceptSelectDefinitionDeserializationTest.java
@@ -0,0 +1,69 @@
+package com.bakdata.conquery.quarkus.concepts.selects.concept;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+
+import java.util.List;
+
+import com.bakdata.conquery.quarkus.concepts.selects.concept.definitions.QuarterConceptSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ConceptSelectId;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.quarkus.test.junit.QuarkusTest;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+@QuarkusTest
+class ConceptSelectDefinitionDeserializationTest {
+
+	@Inject
+	ObjectMapper objectMapper;
+
+	@ParameterizedTest
+	@ValueSource(strings = {"EXISTS", "QUARTER", "EVENT_DATE_UNION", "EVENT_DURATION_SUM", "CONCEPT_VALUES"})
+	void deserializesEveryRegisteredType(String type) throws Exception {
+		String sample = type.equals("QUARTER") ? ",\"sample\":\"EARLIEST\"" : "";
+		ConceptSelectDefinition definition = objectMapper.readValue("{\"type\":\"" + type + "\"" + sample + "}", ConceptSelectDefinition.class);
+
+		assertFalse(definition instanceof UnknownConceptSelectDefinition, type);
+		assertEquals(type, definition.getType());
+	}
+
+	@Test
+	void acceptsScalarWhereConceptSelectListIsExpected() throws Exception {
+		ConceptSelectList payload = objectMapper.readValue("""
+				{"selects":{"type":"QUARTER","sample":"LATEST"}}
+				""", ConceptSelectList.class);
+
+		QuarterConceptSelectDefinition quarter = assertInstanceOf(QuarterConceptSelectDefinition.class, payload.selects().getFirst());
+		assertEquals(QuarterConceptSelectDefinition.TemporalSampler.LATEST, quarter.getSample());
+	}
+
+	@Test
+	void keepsUnknownTypeAsExplicitFallbackModel() throws Exception {
+		ConceptSelectDefinition definition = objectMapper.readValue("""
+				{"type":"EXTENSION_CONCEPT_SELECT","option":true}
+				""", ConceptSelectDefinition.class);
+
+		UnknownConceptSelectDefinition unknown = assertInstanceOf(UnknownConceptSelectDefinition.class, definition);
+		assertEquals(true, unknown.properties().get("option"));
+	}
+
+	@Test
+	void serializesTypedConceptSelectIdAsString() throws Exception {
+		ConceptSelectId nested = ConceptSelectId.parse("demo.concept.select");
+		ConceptSelectId root = ConceptSelectId.parse("demo.select");
+
+		assertEquals("demo.concept.select", nested.toString());
+		assertEquals("demo.concept", nested.conceptId().toString());
+		assertEquals("demo.select", root.toString());
+		assertEquals("demo", root.conceptId().toString());
+		assertEquals("\"demo.concept.select\"", objectMapper.writeValueAsString(nested));
+		assertEquals(nested, objectMapper.readValue("\"demo.concept.select\"", ConceptSelectId.class));
+	}
+
+	private record ConceptSelectList(List<ConceptSelectDefinition> selects) {
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/models/PolymorphicModelsOpenApiTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/models/PolymorphicModelsOpenApiTest.java
new file mode 100644
index 0000000000..3e812b82f4
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/models/PolymorphicModelsOpenApiTest.java
@@ -0,0 +1,99 @@
+package com.bakdata.conquery.quarkus.models;
+
+import static io.restassured.RestAssured.given;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.quarkus.test.junit.QuarkusTest;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.Test;
+
+@QuarkusTest
+class PolymorphicModelsOpenApiTest {
+
+	@Inject
+	ObjectMapper objectMapper;
+
+	@Test
+	void exposesRegisteredFilterModelsAsDiscriminatedSchema() throws Exception {
+		String document = given()
+				.queryParam("format", "json")
+				.when().get("/q/openapi")
+				.then().statusCode(200)
+				.extract().asString();
+		JsonNode schemas = objectMapper.readTree(document).path("components").path("schemas");
+		JsonNode filterSchema = schemas.path("MetadataFilterDefinition");
+
+		assertEquals("type", filterSchema.path("discriminator").path("propertyName").asText());
+		assertEquals("#/components/schemas/MetadataCountFilter", filterSchema.path("discriminator").path("mapping").path("COUNT").asText());
+		assertTrue(filterSchema.path("oneOf").isArray());
+		assertEquals(13, filterSchema.path("oneOf").size());
+
+		JsonNode countSchema = schemas.path("MetadataCountFilter");
+		assertTrue(countSchema.isObject());
+		assertEquals("COUNT", findProperty(countSchema, "type").path("const").asText());
+		assertNotNull(findProperty(countSchema, "column"));
+		assertNotNull(findProperty(countSchema, "distinctByColumn"));
+
+		JsonNode selectSchema = schemas.path("MetadataSelectDefinition");
+		assertEquals("type", selectSchema.path("discriminator").path("propertyName").asText());
+		assertEquals("#/components/schemas/MetadataCountSelect", selectSchema.path("discriminator").path("mapping").path("COUNT").asText());
+		assertEquals(13, selectSchema.path("oneOf").size());
+
+		JsonNode countSelectSchema = schemas.path("MetadataCountSelect");
+		assertEquals("COUNT", findProperty(countSelectSchema, "type").path("const").asText());
+		assertNotNull(findProperty(countSelectSchema, "column"));
+		assertNotNull(findProperty(countSelectSchema, "distinctByColumn"));
+
+		JsonNode conceptSelectSchema = schemas.path("MetadataConceptSelectDefinition");
+		assertEquals("type", conceptSelectSchema.path("discriminator").path("propertyName").asText());
+		assertEquals("#/components/schemas/MetadataExistsConceptSelect", conceptSelectSchema.path("discriminator").path("mapping").path("EXISTS").asText());
+		assertEquals(5, conceptSelectSchema.path("oneOf").size());
+
+		JsonNode quarterConceptSelectSchema = schemas.path("MetadataQuarterConceptSelect");
+		assertEquals("QUARTER", findProperty(quarterConceptSelectSchema, "type").path("const").asText());
+		assertNotNull(findProperty(quarterConceptSelectSchema, "sample"));
+
+		JsonNode conditionSchema = schemas.path("MetadataConceptCondition");
+		assertEquals("type", conditionSchema.path("discriminator").path("propertyName").asText());
+		assertEquals("#/components/schemas/MetadataEqualConceptCondition", conditionSchema.path("discriminator").path("mapping").path("EQUAL").asText());
+		assertEquals("#/components/schemas/MetadataAndConceptCondition", conditionSchema.path("discriminator").path("mapping").path("AND").asText());
+		assertEquals(8, conditionSchema.path("oneOf").size());
+
+		JsonNode andConditionSchema = schemas.path("MetadataAndConceptCondition");
+		assertEquals("AND", findProperty(andConditionSchema, "type").path("const").asText());
+		assertNotNull(findProperty(andConditionSchema, "conditions"));
+
+		JsonNode filterValueSchema = schemas.path("QueryFilterValue");
+		assertEquals("type", filterValueSchema.path("discriminator").path("propertyName").asText());
+		assertEquals("#/components/schemas/QuerySelectFilterValue", filterValueSchema.path("discriminator").path("mapping").path("SELECT").asText());
+		assertEquals(9, filterValueSchema.path("oneOf").size());
+		assertEquals("#/components/schemas/MetadataMultiSelectFilter", filterSchema.path("discriminator").path("mapping").path("SELECT").asText());
+
+		JsonNode integerRangeFilterValueSchema = schemas.path("QueryIntegerRangeFilterValue");
+		assertEquals("INTEGER_RANGE", findProperty(integerRangeFilterValueSchema, "type").path("const").asText());
+		assertEquals("#/components/schemas/FilterId", findProperty(integerRangeFilterValueSchema, "filter").path("$ref").asText());
+		assertNotNull(findProperty(integerRangeFilterValueSchema, "value"));
+
+		JsonNode filterIdSchema = schemas.path("FilterId");
+		assertEquals("string", filterIdSchema.path("type").asText());
+		assertTrue(filterIdSchema.path("properties").isMissingNode());
+	}
+
+	private JsonNode findProperty(JsonNode schema, String name) {
+		JsonNode property = schema.path("properties").path(name);
+		if (!property.isMissingNode()) {
+			return property;
+		}
+		for (JsonNode parent : schema.path("allOf")) {
+			JsonNode inherited = findProperty(parent, name);
+			if (inherited != null) {
+				return inherited;
+			}
+		}
+		return null;
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/services/DatasetServiceTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/services/DatasetServiceTest.java
new file mode 100644
index 0000000000..24603cb464
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/services/DatasetServiceTest.java
@@ -0,0 +1,110 @@
+package com.bakdata.conquery.quarkus.services;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.concepts.conditions.ConceptCondition;
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.EqualConceptCondition;
+import com.bakdata.conquery.quarkus.ids.ConceptId;
+import com.bakdata.conquery.quarkus.ids.DatasetId;
+import com.bakdata.conquery.quarkus.ids.TableId;
+import com.bakdata.conquery.quarkus.ids.StructureNodeId;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import com.bakdata.conquery.quarkus.storage.NamespaceStorage;
+import com.bakdata.conquery.quarkus.storage.NamespaceStorageRegistry;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+class DatasetServiceTest {
+
+	@Test
+	@Disabled("Endpoint not yet implemented")
+	void resolvesConceptCodesAgainstRequestedConceptSubtree() {
+		DatasetService service = new DatasetService();
+		service.namespaceStorageRegistry = new TestNamespaceStorageRegistry(List.of(
+				new DatasetCatalogRepository.Concept(cid("demo.icd"), "ICD", null, List.of(), false, Map.of(
+
+						cid("demo.icd.a00"), new DatasetCatalogRepository.ConceptElement(cid("demo.icd.a00"), "A00", null, List.of(), cid("demo.icd"), List.of(cid("demo.icd.a00.a00_0")), equal("A00", "A000")),
+						cid("demo.icd.a00.a00_0"), new DatasetCatalogRepository.ConceptElement(cid("demo.icd.a00.a00_0"), "A00.0", null, List.of(), cid("demo.icd.a00"), List.of(), equal("A000"))
+
+				), List.of(cid("demo.icd.a00")), null, List.of()),
+				new DatasetCatalogRepository.Concept(cid("demo.other"), "Other", null, List.of(), false, null, null, List.of(), List.of())
+		));
+
+		DatasetService.ConceptCodeResolution resolution = service.resolveConceptCodes("demo.icd", List.of("A00", "A000", "OTHER", "UNKNOWN"));
+
+		assertEquals(List.of("demo.icd.a00", "demo.icd.a00.a00_0"), resolution.resolvedConcepts());
+		assertEquals(List.of("OTHER", "UNKNOWN"), resolution.unknownCodes());
+	}
+
+	private ConceptCondition equal(String... values) {
+		EqualConceptCondition condition = new EqualConceptCondition();
+		condition.setType("EQUAL");
+		condition.setValues(List.of(values));
+		return condition;
+	}
+
+	private ConceptId cid(String value) {
+		return ConceptId.parse(value);
+	}
+
+	private static DatasetId did(String value) {
+		return DatasetId.parse(value);
+	}
+
+	private record TestNamespaceStorageRegistry(List<DatasetCatalogRepository.Concept> concepts) implements NamespaceStorageRegistry {
+		@Override
+		public List<DatasetCatalogRepository.DatasetRecord> listDatasets() {
+			return List.of(new DatasetCatalogRepository.DatasetRecord(did("demo"), "Demo", "analytics"));
+		}
+
+		@Override
+		public Optional<NamespaceStorage> findNamespace(DatasetId datasetId) {
+			if (!did("demo").equals(datasetId)) {
+				return Optional.empty();
+			}
+			return Optional.of(new TestNamespaceStorage(concepts));
+		}
+	}
+
+	private record TestNamespaceStorage(List<DatasetCatalogRepository.Concept> concepts) implements NamespaceStorage {
+		@Override
+		public DatasetCatalogRepository.DatasetRecord dataset() {
+			return new DatasetCatalogRepository.DatasetRecord(did("demo"), "Demo", "analytics");
+		}
+
+		@Override
+		public List<DatasetCatalogRepository.Concept> listConcepts() {
+			return concepts;
+		}
+
+		@Override
+		public Optional<DatasetCatalogRepository.Concept> findConcept(ConceptId conceptId) {
+			return concepts.stream().filter(concept -> concept.id().equals(conceptId)).findFirst();
+		}
+
+		@Override
+		public List<DatasetCatalogRepository.StructureNode> listStructureNodes() {
+			return List.of();
+		}
+
+		@Override
+		public Optional<DatasetCatalogRepository.StructureNode> findStructureNode(StructureNodeId structureNodeId) {
+			return Optional.empty();
+		}
+
+		@Override
+		public List<DatasetCatalogRepository.TableRecord> listTables() {
+			return List.of();
+		}
+
+		@Override
+		public Optional<DatasetCatalogRepository.TableRecord> findTable(TableId tableId) {
+			return Optional.empty();
+		}
+
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/sql/SqlDatasourceRegistryTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/sql/SqlDatasourceRegistryTest.java
new file mode 100644
index 0000000000..3b8ad52816
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/sql/SqlDatasourceRegistryTest.java
@@ -0,0 +1,41 @@
+package com.bakdata.conquery.quarkus.sql;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import java.util.Map;
+
+import com.bakdata.conquery.quarkus.config.SqlRuntimeConfig;
+import com.bakdata.conquery.quarkus.ids.DatasetId;
+import com.bakdata.conquery.quarkus.storage.DatasetCatalogRepository;
+import org.junit.jupiter.api.Test;
+
+class SqlDatasourceRegistryTest {
+
+	@Test
+	void resolvesSharedNamedDatasourceOnce() {
+		SqlRuntimeConfig.SqlDataSource analytics = () -> SqlRuntimeConfig.SqlDialect.CLICKHOUSE;
+		Map<String, SqlRuntimeConfig.SqlDialect> resolved = SqlDatasourceRegistry.resolveDialectMappings(
+				List.of(dataset("claims", "analytics"), dataset("diagnoses", "analytics")),
+				Map.of("analytics", analytics)
+		);
+
+		assertEquals(Map.of("analytics", SqlRuntimeConfig.SqlDialect.CLICKHOUSE), resolved);
+	}
+
+	@Test
+	void rejectsDatasetWithoutDialectMetadata() {
+		IllegalStateException error = assertThrows(
+				IllegalStateException.class,
+				() -> SqlDatasourceRegistry.resolveDialectMappings(List.of(dataset("claims", "analytics")), Map.of())
+		);
+
+		assertTrue(error.getMessage().contains("conquery.sql.datasources.analytics.dialect"));
+	}
+
+	private DatasetCatalogRepository.DatasetRecord dataset(String id, String dataSource) {
+		return new DatasetCatalogRepository.DatasetRecord(DatasetId.parse(id), id, dataSource);
+	}
+}
diff --git a/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/storage/DatasetMetadataFolderLoaderTest.java b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/storage/DatasetMetadataFolderLoaderTest.java
new file mode 100644
index 0000000000..ed2f725c3f
--- /dev/null
+++ b/backend-quarkus/src/test/java/com/bakdata/conquery/quarkus/storage/DatasetMetadataFolderLoaderTest.java
@@ -0,0 +1,582 @@
+package com.bakdata.conquery.quarkus.storage;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+import com.bakdata.conquery.quarkus.config.DatasetMetadataRuntimeConfig;
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.AndConceptCondition;
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.ColumnEqualConceptCondition;
+import com.bakdata.conquery.quarkus.concepts.conditions.definitions.EqualConceptCondition;
+import com.bakdata.conquery.quarkus.concepts.filters.FilterDefinitionAssembler;
+import com.bakdata.conquery.quarkus.concepts.filters.definitions.CountFilterDefinition;
+import com.bakdata.conquery.quarkus.concepts.selects.SelectDefinitionAssembler;
+import com.bakdata.conquery.quarkus.concepts.selects.definitions.FirstSelectDefinition;
+import com.bakdata.conquery.quarkus.concepts.selects.concept.ConceptSelectDefinitionAssembler;
+import com.bakdata.conquery.quarkus.concepts.selects.concept.definitions.ExistsConceptSelectDefinition;
+import com.bakdata.conquery.quarkus.ids.ColumnId;
+import com.bakdata.conquery.quarkus.ids.ConceptId;
+import com.bakdata.conquery.quarkus.ids.ConceptSelectId;
+import com.bakdata.conquery.quarkus.ids.DatasetId;
+import com.bakdata.conquery.quarkus.ids.FilterId;
+import com.bakdata.conquery.quarkus.ids.SelectId;
+import com.bakdata.conquery.quarkus.ids.StructureNodeId;
+import com.bakdata.conquery.quarkus.ids.TableId;
+import com.bakdata.conquery.quarkus.ids.ValidityDateId;
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.quarkus.test.junit.QuarkusTest;
+import jakarta.inject.Inject;
+import jakarta.validation.ConstraintViolationException;
+import jakarta.validation.Validator;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+@QuarkusTest
+class DatasetMetadataFolderLoaderTest {
+
+	@Inject
+	Validator validator;
+
+	@Inject
+	FilterDefinitionAssembler filterDefinitionAssembler;
+
+	@Inject
+	SelectDefinitionAssembler selectDefinitionAssembler;
+
+	@Inject
+	ConceptSelectDefinitionAssembler conceptSelectDefinitionAssembler;
+
+	@Inject
+	ObjectMapper objectMapper;
+
+	@Test
+	void loadsConfiguredMetadataFolderAndScopesIds(@TempDir Path tempDir) throws Exception {
+		Path root = tempDir.resolve("gen");
+		Path demo = root.resolve("demo");
+		Files.createDirectories(demo.resolve("conceptTrees"));
+		Files.createDirectories(demo.resolve("tables"));
+
+		Files.writeString(
+				demo.resolve("dataset.json"),
+				"""
+				{
+				  "id":"fdb_demo",
+				  "dataSource":"analytics"
+				}
+				"""
+		);
+		Files.writeString(
+				demo.resolve("structure_demo.json"),
+				"""
+				[
+				  {
+				    "label":"Group 1",
+				    "children":[{"name":"diagnoses","label":"Diagnoses","containedRoots":["icd"]}]
+				  },
+				  {"label":"Group 2"}
+				]
+				"""
+		);
+		Files.writeString(
+				demo.resolve("conceptTrees/icd.concept.json"),
+				"""
+				{
+				  "name":"icd",
+				  "label":"ICD",
+				  "connectors": [
+				  	{
+				  		"label": "kh-diagnose",
+				  		"name": "kh_diagnose",
+				  		"table": "kh_diagnose",
+						"default": false,
+				  		"filters": [
+				  		  {
+				  		    "type": "SELECT",
+				  		    "label": "ICD Code",
+				  		    "column": "icd_code",
+				  		    "labels": {
+				  		      "A00": "A00",
+				  		      "A000": "A00.0"
+				  		    }
+				  		  },
+				  		  {
+				  		    "type": "COUNT",
+				  		    "name": "icd_count",
+				  		    "label": "ICD Count",
+				  		    "column": "icd_code",
+				  		    "distinctByColumn": "entlassungsdatum"
+				  		  }
+				  		]
+				  	}
+				  ],
+				  "children":[
+				    {
+				      "name":"a00",
+				      "label":"A00",
+				      "condition":{"type":"AND","conditions":[{"type":"EQUAL","values":["A00","A000"]},{"type":"COLUMN_EQUAL","column":"aufnahmeart","values":["stationaer"]}]},
+				      "children":[
+				        {
+				          "label":"A00.0",
+				          "condition":{"type":"EQUAL","values":["A000"]},
+				          "children":[]
+				        }
+				      ]
+				    }
+				  ]
+				}
+				"""
+		);
+		Files.writeString(
+				demo.resolve("tables/kh_diagnose.table.json"),
+				"""
+				{
+				  "name":"kh_diagnose",
+				  "columns":[
+				    {"name":"icd_code","type":"STRING","secondaryId":"icd_code"},
+				    {"name":"entlassungsdatum","type":"DATE"}
+				  ]
+				}
+				"""
+		);
+
+		DatasetMetadataFolderLoader loader = new DatasetMetadataFolderLoader();
+		loader.objectMapper = objectMapper;
+		loader.validator = validator;
+		loader.filterDefinitionAssembler = filterDefinitionAssembler;
+		loader.selectDefinitionAssembler = selectDefinitionAssembler;
+		loader.conceptSelectDefinitionAssembler = conceptSelectDefinitionAssembler;
+		loader.metadataConfig = new DatasetMetadataRuntimeConfig() {
+			@Override
+			public boolean enabled() {
+				return true;
+			}
+
+			@Override
+			public Optional<String> rootPath() {
+				return Optional.of(root.toString());
+			}
+
+			@Override
+			public Optional<List<String>> folders() {
+				return Optional.of(List.of("demo"));
+			}
+
+			@Override
+			public boolean strictFilterTypes() {
+				return true;
+			}
+
+			@Override
+			public boolean strictSelectTypes() {
+				return true;
+			}
+		};
+
+		List<DatasetMetadataFolderLoader.LoadedDatasetMetadata> loaded = loader.loadConfiguredDatasets();
+		assertEquals(1, loaded.size());
+
+		DatasetMetadataFolderLoader.LoadedDatasetMetadata dataset = loaded.getFirst();
+		assertEquals(DatasetId.parse("fdb_demo"), dataset.dataset().id());
+		assertEquals("demo", dataset.dataset().label());
+		assertEquals("analytics", dataset.dataset().dataSource());
+
+		assertTrue(dataset.conceptsById().containsKey(ConceptId.parse("fdb_demo.icd")));
+		DatasetCatalogRepository.Concept concept = dataset.conceptsById().get(ConceptId.parse("fdb_demo.icd"));
+		assertEquals("ICD", concept.label());
+		assertEquals(List.of(ConceptId.parse("fdb_demo.icd.a00")), concept.childrenIds());
+		assertEquals(false, concept.connectors().getFirst().isDefault());
+		assertEquals(3, dataset.structureNodesById().size());
+		DatasetCatalogRepository.StructureNode diagnoses = dataset.structureNodesById().get(StructureNodeId.parse("fdb_demo.Group_1.diagnoses"));
+		assertEquals(StructureNodeId.parse("fdb_demo.Group_1"), diagnoses.parentId());
+		assertEquals(List.of(ConceptId.parse("fdb_demo.icd")), diagnoses.containedRoots());
+		DatasetCatalogRepository.Filter filter = concept.connectors().getFirst().filters().getFirst();
+		assertEquals(FilterId.parse("fdb_demo.icd.kh_diagnose.ICD_Code"), filter.id());
+		assertEquals("ICD Code", filter.label());
+		assertEquals("MULTI_SELECT", filter.type());
+		assertEquals(List.of(ColumnId.parse("fdb_demo.kh_diagnose.icd_code")), filter.requiredColumns());
+		assertEquals(2, filter.options().size());
+		DatasetCatalogRepository.Filter countFilter = concept.connectors().getFirst().filters().get(1);
+		CountFilterDefinition countDefinition = assertInstanceOf(CountFilterDefinition.class, countFilter.definition());
+		assertEquals(List.of("entlassungsdatum"), countDefinition.getDistinctByColumn());
+		assertEquals(FilterId.parse("fdb_demo.icd.kh_diagnose.icd_count"), countFilter.id());
+		assertEquals(
+				List.of(ColumnId.parse("fdb_demo.kh_diagnose.icd_code"), ColumnId.parse("fdb_demo.kh_diagnose.entlassungsdatum")),
+				countFilter.requiredColumns()
+		);
+
+		DatasetCatalogRepository.ConceptElement child = concept.children().get(ConceptId.parse("fdb_demo.icd.a00"));
+		assertEquals(ConceptId.parse("fdb_demo.icd"), child.parentId());
+		AndConceptCondition andCondition = assertInstanceOf(AndConceptCondition.class, child.condition());
+		assertEquals(2, andCondition.getConditions().size());
+		EqualConceptCondition equalCondition = assertInstanceOf(EqualConceptCondition.class, andCondition.getConditions().getFirst());
+		assertEquals(List.of("A00", "A000"), equalCondition.getValues());
+		ColumnEqualConceptCondition columnCondition = assertInstanceOf(ColumnEqualConceptCondition.class, andCondition.getConditions().get(1));
+		assertEquals("aufnahmeart", columnCondition.getColumn());
+		assertEquals(List.of("stationaer"), columnCondition.getValues());
+		assertEquals(List.of(ConceptId.parse("fdb_demo.icd.a00.A00_0")), child.children());
+
+		DatasetCatalogRepository.ConceptElement leaf = concept.children().get(ConceptId.parse("fdb_demo.icd.a00.A00_0"));
+		assertEquals(ConceptId.parse("fdb_demo.icd.a00"), leaf.parentId());
+		EqualConceptCondition leafCondition = assertInstanceOf(EqualConceptCondition.class, leaf.condition());
+		assertEquals(List.of("A000"), leafCondition.getValues());
+
+		assertTrue(dataset.tablesById().containsKey(TableId.parse("fdb_demo.kh_diagnose")));
+		DatasetCatalogRepository.TableRecord table = dataset.tablesById().get(TableId.parse("fdb_demo.kh_diagnose"));
+		assertEquals(ColumnId.parse("fdb_demo.kh_diagnose.icd_code"), table.columns().get(0).id());
+		assertEquals("icd_code", table.columns().get(0).secondaryId());
+		assertEquals(ColumnId.parse("fdb_demo.kh_diagnose.entlassungsdatum"), table.columns().get(1).id());
+		assertNotNull(table.columns().get(1).type());
+	}
+
+	@Test
+	void loadsDevConfigMetadataFixtures() throws Exception {
+		Path root = Path.of(Objects.requireNonNull(getClass().getResource("/test-meta-data")).toURI());
+
+		DatasetMetadataFolderLoader loader = new DatasetMetadataFolderLoader();
+		loader.objectMapper = objectMapper;
+		loader.validator = validator;
+		loader.filterDefinitionAssembler = filterDefinitionAssembler;
+		loader.selectDefinitionAssembler = selectDefinitionAssembler;
+		loader.conceptSelectDefinitionAssembler = conceptSelectDefinitionAssembler;
+		loader.metadataConfig = new DatasetMetadataRuntimeConfig() {
+			@Override
+			public boolean enabled() {
+				return true;
+			}
+
+			@Override
+			public Optional<String> rootPath() {
+				return Optional.of(root.toString());
+			}
+
+			@Override
+			public Optional<List<String>> folders() {
+				return Optional.of(List.of("imdb", "empty_set"));
+			}
+
+			@Override
+			public boolean strictFilterTypes() {
+				return true;
+			}
+
+			@Override
+			public boolean strictSelectTypes() {
+				return true;
+			}
+		};
+
+		List<DatasetMetadataFolderLoader.LoadedDatasetMetadata> loaded = loader.loadConfiguredDatasets();
+		assertEquals(2, loaded.size());
+
+		DatasetMetadataFolderLoader.LoadedDatasetMetadata imdb = loaded.stream()
+																	  .filter(metadata -> metadata.dataset().id().equals(DatasetId.parse("imdb")))
+																	  .findFirst()
+																	  .orElseThrow();
+		assertEquals(DatasetId.parse("imdb"), imdb.dataset().id());
+		assertEquals("IMDb", imdb.dataset().label());
+		assertEquals("imdb", imdb.dataset().dataSource());
+		assertTrue(imdb.conceptsById().containsKey(ConceptId.parse("imdb")));
+		DatasetCatalogRepository.Filter titleFilter = imdb.conceptsById().get(ConceptId.parse("imdb")).connectors().getFirst().filters().getFirst();
+		assertEquals(FilterId.parse("imdb.titles.release_age"), titleFilter.id());
+		assertEquals("INTEGER_RANGE", titleFilter.type());
+		assertEquals(List.of(ColumnId.parse("imdb.title.release_date")), titleFilter.requiredColumns());
+		DatasetCatalogRepository.Select titleSelect = imdb.conceptsById().get(ConceptId.parse("imdb")).connectors().getFirst().selects().getFirst();
+		assertEquals(SelectId.parse("imdb.titles.Title"), titleSelect.id());
+		assertEquals("FIRST", titleSelect.implementationType());
+		assertInstanceOf(FirstSelectDefinition.class, titleSelect.definition());
+		assertEquals(DatasetCatalogRepository.SelectResultType.primitive("STRING"), titleSelect.resultType());
+		assertEquals(List.of(ColumnId.parse("imdb.title.name")), titleSelect.requiredColumns());
+		DatasetCatalogRepository.ConceptSelect conceptSelect = imdb.conceptsById().get(ConceptId.parse("imdb")).selects().getFirst();
+		assertEquals(ConceptSelectId.parse("imdb.exists"), conceptSelect.id());
+		assertEquals("EXISTS", conceptSelect.implementationType());
+		assertInstanceOf(ExistsConceptSelectDefinition.class, conceptSelect.definition());
+		assertEquals(DatasetCatalogRepository.SelectResultType.primitive("BOOLEAN"), conceptSelect.resultType());
+		DatasetCatalogRepository.Connector titleConnector = imdb.conceptsById().get(ConceptId.parse("imdb")).connectors().getFirst();
+		assertEquals("Choose the release date", titleConnector.validityDatesDescription());
+		DatasetCatalogRepository.ValidityDate releaseDate = titleConnector.validityDates().getFirst();
+		assertEquals(ValidityDateId.parse("imdb.titles.Release_date"), releaseDate.id());
+		assertEquals("Release date", releaseDate.label());
+		assertEquals(ColumnId.parse("imdb.title.release_date"), releaseDate.columnId());
+		assertTrue(imdb.tablesById().containsKey(TableId.parse("imdb.title")));
+
+		DatasetCatalogRepository.TableRecord title = imdb.tablesById().get(TableId.parse("imdb.title"));
+		assertEquals("Titles", title.label());
+		assertEquals(ColumnId.parse("imdb.title.id"), title.primaryColumn());
+		assertEquals(3, title.columns().size());
+		assertEquals("Title ID", title.columns().getFirst().label());
+		assertEquals(ColumnType.INTEGER, title.columns().get(0).type());
+		assertEquals("pid", title.columns().get(0).secondaryId());
+		assertEquals("Title", title.columns().get(1).label());
+		assertEquals(ColumnType.STRING, title.columns().get(1).type());
+		assertEquals("Release Date", title.columns().get(2).label());
+		assertEquals(ColumnType.DATE, title.columns().get(2).type());
+
+		DatasetMetadataFolderLoader.LoadedDatasetMetadata emptySet = loaded.stream()
+																		   .filter(metadata -> metadata.dataset().id().toString().equals("empty_set"))
+																		   .findFirst()
+																		   .orElseThrow();
+		assertTrue(emptySet.conceptsById().isEmpty());
+		assertTrue(emptySet.tablesById().isEmpty());
+	}
+
+	@Test
+	void fallsBackToFolderNameWhenDatasetJsonIsMissing(@TempDir Path tempDir) throws Exception {
+		Path root = tempDir.resolve("test-datasets");
+		String datasetName = "fallback_dataset_name";
+		Path fallback = root.resolve(datasetName);
+		Files.createDirectories(fallback.resolve("conceptTrees"));
+		Files.createDirectories(fallback.resolve("tables"));
+
+		DatasetMetadataFolderLoader loader = new DatasetMetadataFolderLoader();
+		loader.objectMapper = objectMapper;
+		loader.validator = validator;
+		loader.filterDefinitionAssembler = filterDefinitionAssembler;
+		loader.selectDefinitionAssembler = selectDefinitionAssembler;
+		loader.conceptSelectDefinitionAssembler = conceptSelectDefinitionAssembler;
+		loader.metadataConfig = new DatasetMetadataRuntimeConfig() {
+			@Override
+			public boolean enabled() {
+				return true;
+			}
+
+			@Override
+			public Optional<String> rootPath() {
+				return Optional.of(root.toString());
+			}
+
+			@Override
+			public Optional<List<String>> folders() {
+				return Optional.of(List.of(datasetName));
+			}
+
+			@Override
+			public boolean strictFilterTypes() {
+				return true;
+			}
+
+			@Override
+			public boolean strictSelectTypes() {
+				return true;
+			}
+		};
+
+		DatasetCatalogRepository.DatasetRecord dataset = loader.loadConfiguredDatasets().getFirst().dataset();
+		assertEquals(DatasetId.parse(datasetName), dataset.id());
+		assertEquals(datasetName, dataset.label());
+		assertEquals(datasetName, dataset.dataSource());
+	}
+
+	@Test
+	void skipsUnknownFilterInLenientModeAndRejectsItInStrictMode(@TempDir Path tempDir) throws Exception {
+		Path dataset = tempDir.resolve("demo");
+		Files.createDirectories(dataset.resolve("conceptTrees"));
+		Files.createDirectories(dataset.resolve("tables"));
+		Files.writeString(dataset.resolve("tables/events.table.json"), """
+				{"name":"events","columns":[{"name":"value","type":"STRING"}]}
+				""");
+		Files.writeString(dataset.resolve("conceptTrees/events.concept.json"), """
+				{
+				  "name":"events",
+				  "children":[],
+				  "connectors":[{
+				    "name":"events",
+				    "table":"events",
+				    "filters":[{"type":"EXTERNAL_FILTER","column":"value"}]
+				  }]
+				}
+				""");
+
+		DatasetMetadataFolderLoader lenientLoader = loader(tempDir, false);
+		DatasetCatalogRepository.Concept concept = lenientLoader.loadConfiguredDatasets().getFirst().conceptsById().get(ConceptId.parse("demo.events"));
+		assertTrue(concept.connectors().getFirst().filters().isEmpty());
+
+		DatasetMetadataFolderLoader strictLoader = loader(tempDir, true);
+		IllegalStateException error = assertThrows(IllegalStateException.class, strictLoader::loadConfiguredDatasets);
+		assertTrue(error.getMessage().contains("unknown filter type 'EXTERNAL_FILTER'"));
+	}
+
+	@Test
+	void skipsUnknownSelectInLenientModeAndRejectsItInStrictMode(@TempDir Path tempDir) throws Exception {
+		Path dataset = tempDir.resolve("demo");
+		Files.createDirectories(dataset.resolve("conceptTrees"));
+		Files.createDirectories(dataset.resolve("tables"));
+		Files.writeString(dataset.resolve("tables/events.table.json"), """
+				{"name":"events","columns":[{"name":"value","type":"STRING"}]}
+				""");
+		Files.writeString(dataset.resolve("conceptTrees/events.concept.json"), """
+				{
+				  "name":"events",
+				  "children":[],
+				  "connectors":[{
+				    "name":"events",
+				    "table":"events",
+				    "selects":[{"type":"EXTERNAL_SELECT","column":"value"}]
+				  }]
+				}
+				""");
+
+		DatasetCatalogRepository.Concept concept = loader(tempDir, false).loadConfiguredDatasets().getFirst().conceptsById().get(ConceptId.parse("demo.events"));
+		assertTrue(concept.connectors().getFirst().selects().isEmpty());
+
+		IllegalStateException error = assertThrows(IllegalStateException.class, () -> loader(tempDir, true).loadConfiguredDatasets());
+		assertTrue(error.getMessage().contains("unknown select type 'EXTERNAL_SELECT'"));
+	}
+
+	@Test
+	void skipsUnknownConceptSelectInLenientModeAndRejectsItInStrictMode(@TempDir Path tempDir) throws Exception {
+		Path dataset = tempDir.resolve("demo");
+		Files.createDirectories(dataset.resolve("conceptTrees"));
+		Files.createDirectories(dataset.resolve("tables"));
+		Files.writeString(dataset.resolve("conceptTrees/events.concept.json"), """
+				{
+				  "name":"events",
+				  "children":[],
+				  "connectors":[],
+				  "selects":{"type":"EXTERNAL_CONCEPT_SELECT","name":"external"}
+				}
+				""");
+
+		DatasetCatalogRepository.Concept concept = loader(tempDir, false).loadConfiguredDatasets().getFirst().conceptsById().get(ConceptId.parse("demo.events"));
+		assertTrue(concept.selects().isEmpty());
+
+		IllegalStateException error = assertThrows(IllegalStateException.class, () -> loader(tempDir, true).loadConfiguredDatasets());
+		assertTrue(error.getMessage().contains("unknown concept select type 'EXTERNAL_CONCEPT_SELECT'"));
+	}
+
+	@Test
+	void rejectsStructureNodeWithUnknownConceptAtStartup(@TempDir Path tempDir) throws Exception {
+		Path dataset = tempDir.resolve("demo");
+		Files.createDirectories(dataset.resolve("conceptTrees"));
+		Files.createDirectories(dataset.resolve("tables"));
+		Files.writeString(dataset.resolve("structure_demo.json"), """
+				[{"name":"invalid","containedRoots":["missing"]}]
+				""");
+
+		IllegalStateException error = assertThrows(IllegalStateException.class, () -> loader(tempDir, true).loadConfiguredDatasets());
+		assertTrue(error.getMessage().contains("Structure node 'demo.invalid' references unknown concept 'demo.missing'"));
+	}
+
+	@Test
+	void rejectsIncompleteValidityDateAtStartup(@TempDir Path tempDir) throws Exception {
+		Path dataset = tempDir.resolve("demo");
+		Files.createDirectories(dataset.resolve("conceptTrees"));
+		Files.createDirectories(dataset.resolve("tables"));
+		Files.writeString(dataset.resolve("tables/events.table.json"), """
+				{"name":"events","columns":[{"name":"start","type":"DATE"}]}
+				""");
+		Files.writeString(dataset.resolve("conceptTrees/events.concept.json"), """
+				{
+				  "name":"events",
+				  "children":[],
+				  "connectors":[{
+				    "name":"events",
+				    "table":"events",
+				    "validityDates":{"name":"period","startColumn":"start"}
+				  }]
+				}
+				""");
+
+		IllegalStateException error = assertThrows(IllegalStateException.class, () -> loader(tempDir, true).loadConfiguredDatasets());
+		assertTrue(error.getMessage().contains("Validity date 'demo.events.events.period' must define either column or both startColumn and endColumn"));
+	}
+
+	@Test
+	void rejectsUnknownConceptConditionAtStartup(@TempDir Path tempDir) throws Exception {
+		Path dataset = tempDir.resolve("demo");
+		Files.createDirectories(dataset.resolve("conceptTrees"));
+		Files.createDirectories(dataset.resolve("tables"));
+		Files.writeString(dataset.resolve("conceptTrees/events.concept.json"), """
+				{
+				  "name":"events",
+				  "connectors":[],
+				  "children":[{
+				    "name":"invalid",
+				    "condition":{"type":"EXTERNAL_CONDITION","expression":"value != null"}
+				  }]
+				}
+				""");
+
+		ConstraintViolationException error = assertThrows(
+				ConstraintViolationException.class,
+				() -> loader(tempDir, true).loadConfiguredDatasets()
+		);
+		assertTrue(error.getMessage().contains("children[0].condition.registeredType"));
+		assertTrue(error.getMessage().contains("must use a registered concept condition type"));
+	}
+
+	@Test
+	void reportsCascadedFilterConstraintWithFileAndPropertyPath(@TempDir Path tempDir) throws Exception {
+		Path dataset = tempDir.resolve("demo");
+		Files.createDirectories(dataset.resolve("conceptTrees"));
+		Files.createDirectories(dataset.resolve("tables"));
+		Files.writeString(dataset.resolve("tables/events.table.json"), """
+				{"name":"events","columns":[{"name":"value","type":"INTEGER"}]}
+				""");
+		Path conceptFile = dataset.resolve("conceptTrees/events.concept.json");
+		Files.writeString(conceptFile, """
+				{
+				  "name":"events",
+				  "children":[],
+				  "connectors":[{
+				    "name":"events",
+				    "table":"events",
+				    "filters":[{"type":"NUMBER","name":"missing_column"}]
+				  }]
+				}
+				""");
+
+		ConstraintViolationException error = assertThrows(
+				ConstraintViolationException.class,
+				() -> loader(tempDir, true).loadConfiguredDatasets()
+		);
+
+		assertTrue(error.getMessage().contains(conceptFile.toString()));
+		assertTrue(error.getMessage().contains("connectors[0].filters[0].column:"));
+		assertTrue(error.getMessage().contains("invalid value: null"));
+	}
+
+	private DatasetMetadataFolderLoader loader(Path root, boolean strictFilterTypes) {
+		DatasetMetadataFolderLoader loader = new DatasetMetadataFolderLoader();
+		loader.objectMapper = objectMapper;
+		loader.validator = validator;
+		loader.filterDefinitionAssembler = filterDefinitionAssembler;
+		loader.selectDefinitionAssembler = selectDefinitionAssembler;
+		loader.conceptSelectDefinitionAssembler = conceptSelectDefinitionAssembler;
+		loader.metadataConfig = new DatasetMetadataRuntimeConfig() {
+			@Override
+			public boolean enabled() {
+				return true;
+			}
+
+			@Override
+			public Optional<String> rootPath() {
+				return Optional.of(root.toString());
+			}
+
+			@Override
+			public Optional<List<String>> folders() {
+				return Optional.of(List.of("demo"));
+			}
+
+			@Override
+			public boolean strictFilterTypes() {
+				return strictFilterTypes;
+			}
+
+			@Override
+			public boolean strictSelectTypes() {
+				return strictFilterTypes;
+			}
+		};
+		return loader;
+	}
+}
diff --git a/backend-quarkus/src/test/resources/test-meta-data/empty_set/conceptTrees/.gitkeep b/backend-quarkus/src/test/resources/test-meta-data/empty_set/conceptTrees/.gitkeep
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/backend-quarkus/src/test/resources/test-meta-data/empty_set/conceptTrees/.gitkeep
@@ -0,0 +1 @@
+
diff --git a/backend-quarkus/src/test/resources/test-meta-data/empty_set/dataset.json b/backend-quarkus/src/test/resources/test-meta-data/empty_set/dataset.json
new file mode 100644
index 0000000000..510b4824df
--- /dev/null
+++ b/backend-quarkus/src/test/resources/test-meta-data/empty_set/dataset.json
@@ -0,0 +1,4 @@
+{
+  "id": "empty_set",
+  "label": "Empty Dataset"
+}
diff --git a/backend-quarkus/src/test/resources/test-meta-data/empty_set/structure_empty-set.json b/backend-quarkus/src/test/resources/test-meta-data/empty_set/structure_empty-set.json
new file mode 100644
index 0000000000..fe51488c70
--- /dev/null
+++ b/backend-quarkus/src/test/resources/test-meta-data/empty_set/structure_empty-set.json
@@ -0,0 +1 @@
+[]
diff --git a/backend-quarkus/src/test/resources/test-meta-data/empty_set/tables/.gitkeep b/backend-quarkus/src/test/resources/test-meta-data/empty_set/tables/.gitkeep
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/backend-quarkus/src/test/resources/test-meta-data/empty_set/tables/.gitkeep
@@ -0,0 +1 @@
+
diff --git a/backend-quarkus/src/test/resources/test-meta-data/imdb/conceptTrees/imdb.concept.json b/backend-quarkus/src/test/resources/test-meta-data/imdb/conceptTrees/imdb.concept.json
new file mode 100644
index 0000000000..0eca43e71b
--- /dev/null
+++ b/backend-quarkus/src/test/resources/test-meta-data/imdb/conceptTrees/imdb.concept.json
@@ -0,0 +1,57 @@
+{
+  "name": "imdb",
+  "label": "IMDb",
+  "additionalInfos": [
+    {
+      "key": "Source",
+      "value": "IMDb test metadata"
+    }
+  ],
+  "selects": {
+    "type": "EXISTS",
+    "name": "exists",
+    "label": "Exists",
+    "description": "Whether any title exists",
+    "default": true
+  },
+  "children": [
+    {
+      "name": "movie",
+      "label": "Movie",
+      "additionalInfos": [
+        {
+          "key": "Kind",
+          "value": "Feature film"
+        }
+      ],
+      "children": []
+    }
+  ],
+  "connectors": [
+    {
+      "name": "titles",
+      "label": "Titles",
+      "table": "title",
+      "validityDatesDescription": "Choose the release date",
+      "validityDates": {
+        "label": "Release date",
+        "column": "release_date"
+      },
+      "filters": [
+        {
+          "type": "DATE_DISTANCE",
+          "name": "release_age",
+          "label": "Release Age",
+          "column": "release_date"
+        }
+      ],
+      "selects": {
+        "type": "FIRST",
+        "label": "Title",
+        "description": "First matching title",
+        "default": true,
+        "column": "name"
+      }
+    }
+  ]
+}
diff --git a/backend-quarkus/src/test/resources/test-meta-data/imdb/dataset.json b/backend-quarkus/src/test/resources/test-meta-data/imdb/dataset.json
new file mode 100644
index 0000000000..380eafe470
--- /dev/null
+++ b/backend-quarkus/src/test/resources/test-meta-data/imdb/dataset.json
@@ -0,0 +1,4 @@
+{
+  "id": "imdb",
+  "label": "IMDb"
+}
diff --git a/backend-quarkus/src/test/resources/test-meta-data/imdb/structure_imdb.json b/backend-quarkus/src/test/resources/test-meta-data/imdb/structure_imdb.json
new file mode 100644
index 0000000000..cc7d2be5ac
--- /dev/null
+++ b/backend-quarkus/src/test/resources/test-meta-data/imdb/structure_imdb.json
@@ -0,0 +1,17 @@
+[
+  {
+    "name": "catalog",
+    "label": "Catalog",
+    "description": "Available media concepts",
+    "children": [
+      {
+        "label": "Movies",
+        "containedRoots": ["imdb"]
+      }
+    ]
+  },
+  {
+    "name": "empty",
+    "label": "Empty folder"
+  }
+]
diff --git a/backend-quarkus/src/test/resources/test-meta-data/imdb/tables/titles.table.json b/backend-quarkus/src/test/resources/test-meta-data/imdb/tables/titles.table.json
new file mode 100644
index 0000000000..bd026413b0
--- /dev/null
+++ b/backend-quarkus/src/test/resources/test-meta-data/imdb/tables/titles.table.json
@@ -0,0 +1,23 @@
+{
+  "name": "title",
+  "label": "Titles",
+  "primaryColumn": "imdb.title.id",
+  "columns": [
+    {
+      "id": "imdb.title.id",
+      "label": "Title ID",
+      "type": "INTEGER",
+      "secondaryId": "pid"
+    },
+    {
+      "id": "imdb.title.name",
+      "label": "Title",
+      "type": "STRING"
+    },
+    {
+      "id": "imdb.title.release_date",
+      "label": "Release Date",
+      "type": "DATE"
+    }
+  ]
+}
diff --git a/backend/pom.xml b/backend/pom.xml
index 27a433b345..835a22ff89 100644
--- a/backend/pom.xml
+++ b/backend/pom.xml
@@ -112,6 +112,11 @@
     </build>
 
     <dependencies>
+        <dependency>
+            <groupId>com.bakdata.conquery</groupId>
+            <artifactId>sql-connector</artifactId>
+            <version>${project.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-to-slf4j</artifactId>
@@ -346,7 +351,7 @@
         <dependency>
             <groupId>org.jooq</groupId>
             <artifactId>jooq</artifactId>
-            <version>3.20.2</version>
+            <version>${jooq.version}</version>
         </dependency>
         <dependency>
             <groupId>com.zaxxer</groupId>
diff --git a/backend/src/main/java/com/bakdata/conquery/apiv1/query/concept/filter/FilterValue.java b/backend/src/main/java/com/bakdata/conquery/apiv1/query/concept/filter/FilterValue.java
index 8e597eb813..2e8ecfe384 100644
--- a/backend/src/main/java/com/bakdata/conquery/apiv1/query/concept/filter/FilterValue.java
+++ b/backend/src/main/java/com/bakdata/conquery/apiv1/query/concept/filter/FilterValue.java
@@ -18,7 +18,7 @@
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConnectorSqlTables;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.FilterContext;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import com.bakdata.conquery.sql.conversion.model.filter.SqlFilters;
 import com.fasterxml.jackson.annotation.JacksonInject;
 import com.fasterxml.jackson.annotation.JsonCreator;
diff --git a/backend/src/main/java/com/bakdata/conquery/mode/local/LocalNamespaceHandler.java b/backend/src/main/java/com/bakdata/conquery/mode/local/LocalNamespaceHandler.java
index 8a4a292b61..e458522d30 100644
--- a/backend/src/main/java/com/bakdata/conquery/mode/local/LocalNamespaceHandler.java
+++ b/backend/src/main/java/com/bakdata/conquery/mode/local/LocalNamespaceHandler.java
@@ -49,7 +49,7 @@ public LocalNamespace createNamespace(
 			ResultSetProcessor resultSetProcessor = dialectBundle.getResultSetProcessor(config);
 			SqlExecutionService sqlExecutionService = new SqlExecutionService(dslContext, resultSetProcessor);
 
-			NodeConversions nodeConversions = new NodeConversions(config.getIdColumns(), dialectBundle, dslContext, sqlExecutionService, clock, connection.getConnection().getPrimaryColumn());
+			NodeConversions nodeConversions = new NodeConversions(config.getIdColumns(), dialectBundle, dslContext, clock, connection.getConnection().getPrimaryColumn());
 			SqlConverter sqlConverter = new SqlConverter(nodeConversions, config);
 			ExecutionManager executionManager = new SqlExecutionManager(sqlConverter, sqlExecutionService, metaStorage, datasetRegistry, config);
 			SqlStorageHandler sqlStorageHandler = new SqlStorageHandler(sqlExecutionService);
diff --git a/backend/src/main/java/com/bakdata/conquery/mode/local/SqlEntityResolver.java b/backend/src/main/java/com/bakdata/conquery/mode/local/SqlEntityResolver.java
index 8768f24c98..92b5aafbcc 100644
--- a/backend/src/main/java/com/bakdata/conquery/mode/local/SqlEntityResolver.java
+++ b/backend/src/main/java/com/bakdata/conquery/mode/local/SqlEntityResolver.java
@@ -17,7 +17,7 @@
 import com.bakdata.conquery.models.config.IdColumnConfig;
 import com.bakdata.conquery.models.identifiable.mapping.EntityIdMap;
 import com.bakdata.conquery.models.identifiable.mapping.ExternalId;
-import com.bakdata.conquery.sql.conversion.SharedAliases;
+import com.bakdata.conquery.sql.compiler.ir.SharedAliases;
 import com.bakdata.conquery.sql.conversion.dialect.DialectBundle;
 import com.bakdata.conquery.sql.execution.SqlExecutionService;
 import com.bakdata.conquery.util.DateReader;
diff --git a/backend/src/main/java/com/bakdata/conquery/models/datasets/concepts/select/connector/specific/MappableSingleColumnSelect.java b/backend/src/main/java/com/bakdata/conquery/models/datasets/concepts/select/connector/specific/MappableSingleColumnSelect.java
index 8900fa8d2f..18bf21b494 100644
--- a/backend/src/main/java/com/bakdata/conquery/models/datasets/concepts/select/connector/specific/MappableSingleColumnSelect.java
+++ b/backend/src/main/java/com/bakdata/conquery/models/datasets/concepts/select/connector/specific/MappableSingleColumnSelect.java
@@ -26,9 +26,9 @@
 import com.bakdata.conquery.models.types.ResultType;
 import com.bakdata.conquery.models.types.SemanticType;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConnectorSqlTables;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
 import com.bakdata.conquery.sql.conversion.model.select.SelectContext;
-import com.bakdata.conquery.sql.conversion.model.select.SingleColumnSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SingleColumnSqlSelect;
 import com.bakdata.conquery.sql.execution.ResultSetProcessor;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import io.dropwizard.validation.ValidationMethod;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/Context.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/Context.java
index 4bc8338bd1..9d679eb311 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/Context.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/Context.java
@@ -1,7 +1,7 @@
 package com.bakdata.conquery.sql.conversion;
 
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
-import com.bakdata.conquery.sql.conversion.dialect.DialectBundle;
+import com.bakdata.conquery.sql.conversion.dialect.LegacyCompilerDialect;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
 import com.bakdata.conquery.sql.conversion.model.NameGenerator;
 
@@ -12,14 +12,14 @@ public interface Context {
 
 	ConversionContext getConversionContext();
 
-	DialectBundle getDialectBundle();
+	LegacyCompilerDialect getCompilerDialect();
 
 	default NameGenerator getNameGenerator() {
 		return getConversionContext().getNameGenerator();
 	}
 	
 	default SqlFunctionProvider getFunctionProvider(){
-		return getConversionContext().getDialectBundle().getFunctionProvider();
+		return getConversionContext().getCompilerDialect().getFunctionProvider();
 	}
 
 }
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/Conversions.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/Conversions.java
index 50116dea6e..48a59e2b84 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/Conversions.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/Conversions.java
@@ -13,7 +13,7 @@
  * @param <X> context of the convertible
  * @see Converter
  */
-public abstract class Conversions<C, R, X extends Context> {
+public class Conversions<C, R, X extends Context> {
 
 	@Getter
 	private final List<? extends Converter<? extends C, R, X>> converters;
@@ -29,8 +29,7 @@ public R convert(C node, X context) {
 			if (maybeConverted.isPresent()) {
 				if (converted == null) {
 					converted = maybeConverted.get();
-				}
-				else {
+				} else {
 					throw new IllegalStateException("Multiple Converters for %s".formatted(node));
 				}
 			}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/NodeConversionDispatcher.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/NodeConversionDispatcher.java
new file mode 100644
index 0000000000..64c1749fe9
--- /dev/null
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/NodeConversionDispatcher.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.sql.conversion;
+
+import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
+
+/** Recursively dispatches a query node to its matching SQL converter. */
+@FunctionalInterface
+public interface NodeConversionDispatcher {
+
+	ConversionContext convert(Object node, ConversionContext context);
+}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/NodeConversions.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/NodeConversions.java
index 742538f3a1..6ec5be439f 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/NodeConversions.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/NodeConversions.java
@@ -4,11 +4,9 @@
 import com.bakdata.conquery.models.config.ConqueryConfig;
 import com.bakdata.conquery.models.config.IdColumnConfig;
 import com.bakdata.conquery.models.query.PrintSettings;
-import com.bakdata.conquery.models.query.Visitable;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
-import com.bakdata.conquery.sql.conversion.dialect.DialectBundle;
+import com.bakdata.conquery.sql.conversion.dialect.LegacyCompilerDialect;
 import com.bakdata.conquery.sql.conversion.model.NameGenerator;
-import com.bakdata.conquery.sql.execution.SqlExecutionService;
 import lombok.NonNull;
 import org.jooq.DSLContext;
 
@@ -18,33 +16,36 @@
 /**
  * Entry point for converting {@link QueryDescription} to an SQL query.
  */
-public class NodeConversions extends Conversions<Visitable, ConversionContext, ConversionContext> {
+public class NodeConversions implements NodeConversionDispatcher {
 
+	private final Conversions<Object, ConversionContext, ConversionContext> conversions;
 	private final IdColumnConfig idColumns;
-	private final DialectBundle dialect;
+	private final LegacyCompilerDialect dialect;
 	private final NameGenerator nameGenerator;
-	private final SqlExecutionService executionService;
 	private final Clock clock;
 	@NonNull
 	private final String defaultPrimaryColumn;
 
 	public NodeConversions(
 			IdColumnConfig idColumns,
-			DialectBundle dialectBundle,
+			LegacyCompilerDialect compilerDialect,
 			DSLContext dslContext,
-			SqlExecutionService executionService,
 			Clock clock,
 			String defaultPrimaryColumn
 	) {
-		super(dialectBundle.getNodeConverters(dslContext));
+		this.conversions = new Conversions<>(compilerDialect.getNodeConverters(dslContext));
 		this.idColumns = idColumns;
-		this.dialect = dialectBundle;
-		this.nameGenerator = new NameGenerator(dialectBundle.getNameMaxLength());
-		this.executionService = executionService;
+		this.dialect = compilerDialect;
+		this.nameGenerator = new NameGenerator(compilerDialect.getNameMaxLength());
 		this.clock = clock;
 		this.defaultPrimaryColumn = defaultPrimaryColumn;
 	}
 
+	@Override
+	public ConversionContext convert(Object node, ConversionContext context) {
+		return conversions.convert(node, context);
+	}
+
 	public ConversionContext convert(QueryDescription queryDescription, ConqueryConfig conqueryConfig) {
 		ConversionContext initialCtx = ConversionContext.builder()
 				.idColumns(idColumns)
@@ -54,8 +55,7 @@ public ConversionContext convert(QueryDescription queryDescription, ConqueryConf
 				.clock(clock)
 				.defaultPrimaryColumn(this.defaultPrimaryColumn)
 				.stratificationFunctions(dialect.getStratificationFunctions())
-				.dialectBundle(dialect)
-				.executionService(executionService)
+				.compilerDialect(dialect)
 				.build();
 		return convert(queryDescription, initialCtx);
 	}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQAndConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQAndConverter.java
index 6c8f98ced3..d70deb0efc 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQAndConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQAndConverter.java
@@ -5,7 +5,7 @@
 import com.bakdata.conquery.sql.conversion.model.ConqueryJoinType;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
 import com.bakdata.conquery.sql.conversion.model.QueryStepJoiner;
-import com.bakdata.conquery.sql.conversion.model.select.ExistsSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.ExistsSqlSelect;
 
 public class CQAndConverter implements NodeConverter<CQAnd> {
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQExternalConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQExternalConverter.java
index dd9e63cc36..5b15ee3d1a 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQExternalConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQExternalConverter.java
@@ -12,14 +12,14 @@
 import com.bakdata.conquery.apiv1.query.concept.specific.external.CQExternal;
 import com.bakdata.conquery.models.common.CDateSet;
 import com.bakdata.conquery.sql.conversion.NodeConverter;
-import com.bakdata.conquery.sql.conversion.SharedAliases;
+import com.bakdata.conquery.sql.compiler.ir.SharedAliases;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import com.google.common.base.Preconditions;
 import org.jooq.Field;
 import org.jooq.Name;
@@ -41,7 +41,7 @@ private static QueryStep createExternalIdsCte(CQExternal external, SqlFunctionPr
 			unions.addAll(rowSelects);
 		}
 		Preconditions.checkArgument(!unions.isEmpty(), "Expecting at least 1 resolved row when converting a CQExternal");
-		QueryStep allStep = QueryStep.createUnionAllStep(unions, CQ_EXTERNAL_IDS_CTE_NAME, Collections.emptyList(), context.isNegation(), functionProvider);
+		QueryStep allStep = QueryStep.createUnionAllStep(unions, CQ_EXTERNAL_IDS_CTE_NAME, Collections.emptyList(), context.isNegation());
 
 		Optional<ColumnDateRange> maybeValidityDate = allStep.getSelects().getValidityDate();
 
@@ -152,7 +152,7 @@ public Class<? extends CQExternal> getConversionClass() {
 
 	@Override
 	public ConversionContext convert(CQExternal external, ConversionContext context) {
-		SqlFunctionProvider functionProvider = context.getDialectBundle().getFunctionProvider();
+		SqlFunctionProvider functionProvider = context.getCompilerDialect().getFunctionProvider();
 
 		QueryStep externalIdsCte = createExternalIdsCte(external, functionProvider, context);
 		ConversionContext withExternalIdCte = context.withQueryStep(externalIdsCte);
@@ -173,8 +173,8 @@ private QueryStep createExternalExtrasCte(CQExternal external, SqlFunctionProvid
 			unions.add(rowSelects);
 		}
 		Preconditions.checkArgument(!unions.isEmpty(), "Expecting at least 1 converted resolved row when converting a CQExternal");
-		return QueryStep.createUnionAllStep(unions, CQ_EXTERNAL_EXTRAS_CTE_NAME, Collections.emptyList(), context.isNegation(), functionProvider);
+		return QueryStep.createUnionAllStep(unions, CQ_EXTERNAL_EXTRAS_CTE_NAME, Collections.emptyList(), context.isNegation());
 	}
 
 
-}
\ No newline at end of file
+}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQOrConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQOrConverter.java
index d77d52a207..594de48460 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQOrConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQOrConverter.java
@@ -5,7 +5,7 @@
 import com.bakdata.conquery.sql.conversion.model.ConqueryJoinType;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
 import com.bakdata.conquery.sql.conversion.model.QueryStepJoiner;
-import com.bakdata.conquery.sql.conversion.model.select.ExistsSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.ExistsSqlSelect;
 
 public class CQOrConverter implements NodeConverter<CQOr> {
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQYesConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQYesConverter.java
index f45cba7d1b..17a93fcae4 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQYesConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/CQYesConverter.java
@@ -7,10 +7,10 @@
 import com.bakdata.conquery.apiv1.query.CQYes;
 import com.bakdata.conquery.models.config.ColumnConfig;
 import com.bakdata.conquery.sql.conversion.NodeConverter;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import org.jooq.Field;
 import org.jooq.Record;
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/ConversionContext.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/ConversionContext.java
index a2973ec90d..49612303ef 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/ConversionContext.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/ConversionContext.java
@@ -11,14 +11,12 @@
 import com.bakdata.conquery.models.datasets.SecondaryIdDescription;
 import com.bakdata.conquery.models.query.PrintSettings;
 import com.bakdata.conquery.sql.conversion.Context;
-import com.bakdata.conquery.sql.conversion.NodeConversions;
-import com.bakdata.conquery.sql.conversion.dialect.DialectBundle;
-import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
+import com.bakdata.conquery.sql.conversion.NodeConversionDispatcher;
+import com.bakdata.conquery.sql.conversion.dialect.LegacyCompilerDialect;
 import com.bakdata.conquery.sql.conversion.forms.StratificationFunctions;
 import com.bakdata.conquery.sql.conversion.model.NameGenerator;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
 import com.bakdata.conquery.sql.conversion.model.SqlQuery;
-import com.bakdata.conquery.sql.execution.SqlExecutionService;
 import lombok.Builder;
 import lombok.NonNull;
 import lombok.Singular;
@@ -38,10 +36,9 @@ public class ConversionContext implements Context {
 	StratificationFunctions stratificationFunctions;
 	String defaultPrimaryColumn;
 	PrintSettings sqlPrintSettings;
-	NodeConversions nodeConversions;
-	DialectBundle dialectBundle;
+	NodeConversionDispatcher nodeConversions;
+	LegacyCompilerDialect compilerDialect;
 	NameGenerator nameGenerator;
-	SqlExecutionService executionService;
 	@Singular
 	List<QueryStep> querySteps;
 	@Nullable
@@ -76,7 +73,6 @@ public boolean isWithStratification() {
 	}
 
 
-
 	/**
 	 * Adds a query step to the list of {@link QueryStep} of this context.
 	 */
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/AnsiSqlDateAggregator.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/AnsiSqlDateAggregator.java
index 8656cd9bf4..51eb5cfe47 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/AnsiSqlDateAggregator.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/AnsiSqlDateAggregator.java
@@ -13,11 +13,11 @@
 import com.bakdata.conquery.sql.conversion.dialect.IntervalPacker;
 import com.bakdata.conquery.sql.conversion.dialect.SqlDateAggregator;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
 import com.bakdata.conquery.sql.conversion.model.SqlTables;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import lombok.Data;
 import org.jooq.Field;
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/DateAggregationContext.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/DateAggregationContext.java
index 7eae7cb528..f6c462841d 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/DateAggregationContext.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/DateAggregationContext.java
@@ -7,13 +7,13 @@
 
 import com.bakdata.conquery.sql.conversion.Context;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
-import com.bakdata.conquery.sql.conversion.dialect.DialectBundle;
-import com.bakdata.conquery.sql.conversion.model.Qualifiable;
-import com.bakdata.conquery.sql.conversion.model.QualifyingUtil;
+import com.bakdata.conquery.sql.conversion.dialect.LegacyCompilerDialect;
+import com.bakdata.conquery.sql.compiler.ir.Qualifiable;
+import com.bakdata.conquery.sql.compiler.ir.QualifyingUtil;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import com.bakdata.conquery.sql.conversion.model.SqlTables;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import lombok.Builder;
 import lombok.Value;
 
@@ -63,8 +63,8 @@ public DateAggregationContext qualify(String qualifier) {
 	}
 
 	@Override
-	public DialectBundle getDialectBundle() {
-		return getConversionContext().getDialectBundle();
+	public LegacyCompilerDialect getCompilerDialect() {
+		return getConversionContext().getCompilerDialect();
 	}
 
 }
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/DateAggregationDates.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/DateAggregationDates.java
index c3c7e708e6..a53f27be61 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/DateAggregationDates.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/DateAggregationDates.java
@@ -7,10 +7,10 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/IntermediateTableCte.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/IntermediateTableCte.java
index d7ccea9966..afff1c1983 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/IntermediateTableCte.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/IntermediateTableCte.java
@@ -6,8 +6,8 @@
 
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import lombok.Getter;
 import org.jooq.Condition;
 import org.jooq.Field;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/IntersectAggregationAction.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/IntersectAggregationAction.java
index 70ee2023fb..1b0ff7c716 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/IntersectAggregationAction.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/IntersectAggregationAction.java
@@ -7,12 +7,12 @@
 import java.util.stream.Stream;
 
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.NameGenerator;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
 import com.bakdata.conquery.sql.conversion.model.SqlTables;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import lombok.RequiredArgsConstructor;
 import org.jooq.Field;
 import org.jooq.impl.DSL;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/InvertCte.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/InvertCte.java
index abd998364e..36ce1efe35 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/InvertCte.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/InvertCte.java
@@ -9,11 +9,11 @@
 import java.util.stream.Stream;
 
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
-import com.bakdata.conquery.sql.conversion.model.QualifyingUtil;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.QualifyingUtil;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import lombok.Getter;
 import org.jooq.Condition;
 import org.jooq.Field;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/MergeAggregateAction.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/MergeAggregateAction.java
index d469015d41..67acb1d5e3 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/MergeAggregateAction.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/MergeAggregateAction.java
@@ -7,11 +7,11 @@
 import java.util.stream.Stream;
 
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.NameGenerator;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
 import com.bakdata.conquery.sql.conversion.model.SqlTables;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import lombok.RequiredArgsConstructor;
 import org.jooq.Field;
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/NodeNoOverlapCte.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/NodeNoOverlapCte.java
index 0da7709148..07bf08b999 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/NodeNoOverlapCte.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/NodeNoOverlapCte.java
@@ -5,9 +5,9 @@
 import java.util.List;
 import java.util.Optional;
 
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
 import com.bakdata.conquery.sql.conversion.model.SqlTables;
 import lombok.Getter;
 import org.jooq.Condition;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/OverlapCte.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/OverlapCte.java
index 1d6790ea23..5388d688ea 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/OverlapCte.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/OverlapCte.java
@@ -5,9 +5,9 @@
 import java.util.Optional;
 
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
 import lombok.Getter;
 import org.jooq.Condition;
 import org.jooq.Field;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/RowNumberCte.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/RowNumberCte.java
index 01c1dd5299..b51e28f648 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/RowNumberCte.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/RowNumberCte.java
@@ -3,12 +3,12 @@
 import java.util.ArrayList;
 import java.util.Optional;
 
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import lombok.Getter;
 import org.jooq.Field;
 import org.jooq.impl.DSL;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/SqlAggregationAction.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/SqlAggregationAction.java
index 5b98c52122..a9f7c4f172 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/SqlAggregationAction.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/SqlAggregationAction.java
@@ -4,11 +4,11 @@
 
 import com.bakdata.conquery.models.query.queryplan.DateAggregationAction;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.NameGenerator;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
 import com.bakdata.conquery.sql.conversion.model.SqlTables;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 
 /**
  * Represents a subset of {@link DateAggregationAction}.
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/AggregationFilterCte.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/AggregationFilterCte.java
index 85179b7043..cb332d22fa 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/AggregationFilterCte.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/AggregationFilterCte.java
@@ -4,9 +4,9 @@
 import java.util.stream.Collectors;
 
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
 import com.bakdata.conquery.sql.conversion.model.filter.WhereCondition;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import org.jooq.Condition;
 
 class AggregationFilterCte extends ConnectorCte {
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/AggregationSelectCte.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/AggregationSelectCte.java
index 26ae3c6772..0e8e5abe67 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/AggregationSelectCte.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/AggregationSelectCte.java
@@ -4,11 +4,11 @@
 import java.util.Optional;
 import java.util.stream.Stream;
 
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import org.jooq.Field;
 
 class AggregationSelectCte extends ConnectorCte {
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/CQConceptConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/CQConceptConverter.java
index a3ecc000fd..043df25c78 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/CQConceptConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/CQConceptConverter.java
@@ -1,5 +1,6 @@
 package com.bakdata.conquery.sql.conversion.cqelement.concept;
 
+import com.bakdata.conquery.sql.compiler.ir.Selects;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
@@ -19,6 +20,9 @@
 import com.bakdata.conquery.models.identifiable.ids.specific.ConceptElementId;
 import com.bakdata.conquery.models.identifiable.ids.specific.SelectId;
 import com.bakdata.conquery.models.query.queryplan.DateAggregationAction;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import com.bakdata.conquery.sql.conversion.NodeConverter;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
@@ -30,7 +34,6 @@
 import com.bakdata.conquery.sql.conversion.model.select.ConceptSqlSelects;
 import com.bakdata.conquery.sql.conversion.model.select.ConnectorSqlSelects;
 import com.bakdata.conquery.sql.conversion.model.select.SelectContext;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
 import com.bakdata.conquery.util.TablePrimaryColumnUtil;
 import com.google.common.base.Preconditions;
 import org.jooq.Condition;
@@ -65,7 +68,7 @@ private static QueryStep finishConceptConversion(QueryStep predecessor, CQConcep
 		List<ConceptSqlSelects> converted = cqConcept.getSelects().stream()
 				.map(selectId -> {
 					Select select = selectId.resolve();
-					return context.getDialectBundle().getSelectConverter(select).conceptSelect(select, selectContext);
+					return context.getCompilerDialect().getSelectConverter(select).conceptSelect(select, selectContext);
 				})
 				.toList();
 
@@ -247,7 +250,7 @@ private static ConnectorSqlSelects createConceptColumnConnectorSqlSelects(CQConc
 				.map(SelectId::resolve)
 				.filter(select -> select instanceof ConceptColumnSelect)
 				.findFirst()
-				.map(select -> selectContext.getDialectBundle().getSelectConverter(select).connectorSelect(select, selectContext))
+				.map(select -> selectContext.getCompilerDialect().getSelectConverter(select).connectorSelect(select, selectContext))
 				.orElse(ConnectorSqlSelects.none());
 	}
 
@@ -310,7 +313,7 @@ private CQTableContext createTableContext(TablePath tablePath, CQConcept cqConce
 		cqTable.getSelects()
 				.stream()
 				.map(SelectId::resolve)
-				.map(select -> selectContext.getDialectBundle().getSelectConverter(select).connectorSelect(select, selectContext))
+				.map(select -> selectContext.getCompilerDialect().getSelectConverter(select).connectorSelect(select, selectContext))
 				.forEach(allSelectsForTable::add);
 
 		return CQTableContext.builder()
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/CQTableContext.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/CQTableContext.java
index 921cd9f6ee..23b711cc97 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/CQTableContext.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/CQTableContext.java
@@ -7,10 +7,10 @@
 import com.bakdata.conquery.models.datasets.concepts.select.Select;
 import com.bakdata.conquery.sql.conversion.Context;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
-import com.bakdata.conquery.sql.conversion.dialect.DialectBundle;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.conversion.dialect.LegacyCompilerDialect;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import com.bakdata.conquery.sql.conversion.model.filter.SqlFilters;
 import com.bakdata.conquery.sql.conversion.model.select.ConnectorSqlSelects;
 import lombok.Builder;
@@ -47,7 +47,7 @@ public List<ConnectorSqlSelects> allSqlSelects() {
 	}
 
 	@Override
-	public DialectBundle getDialectBundle() {
-		return getConversionContext().getDialectBundle();
+	public LegacyCompilerDialect getCompilerDialect() {
+		return getConversionContext().getCompilerDialect();
 	}
 }
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/FilterContext.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/FilterContext.java
index 6aa498302a..9108d93013 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/FilterContext.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/FilterContext.java
@@ -5,9 +5,9 @@
 import com.bakdata.conquery.apiv1.query.concept.filter.FilterValue;
 import com.bakdata.conquery.sql.conversion.Context;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
-import com.bakdata.conquery.sql.conversion.dialect.DialectBundle;
+import com.bakdata.conquery.sql.conversion.dialect.LegacyCompilerDialect;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Value;
@@ -40,12 +40,12 @@ public static <V> FilterContext<V> forTableExport(SqlIdColumns ids, V value, Con
 	}
 
 	@Override
-	public DialectBundle getDialectBundle() {
-		return getConversionContext().getDialectBundle();
+	public LegacyCompilerDialect getCompilerDialect() {
+		return getConversionContext().getCompilerDialect();
 	}
 
 	public SqlFunctionProvider getFunctionProvider() {
-		return getDialectBundle().getFunctionProvider();
+		return getCompilerDialect().getFunctionProvider();
 	}
 
 }
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/IntervalPackingSelectsCte.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/IntervalPackingSelectsCte.java
index 45e03332c0..0b0d7a8239 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/IntervalPackingSelectsCte.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/IntervalPackingSelectsCte.java
@@ -6,14 +6,14 @@
 import com.bakdata.conquery.models.datasets.concepts.select.concept.specific.EventDateUnionSelect;
 import com.bakdata.conquery.models.datasets.concepts.select.concept.specific.EventDurationSumSelect;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
-import com.bakdata.conquery.sql.conversion.dialect.DialectBundle;
+import com.bakdata.conquery.sql.conversion.dialect.LegacyCompilerDialect;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
 import com.bakdata.conquery.sql.conversion.model.SqlTables;
 import com.bakdata.conquery.sql.conversion.model.select.ConceptSqlSelects;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import com.google.common.base.Preconditions;
 
 public class IntervalPackingSelectsCte {
@@ -23,15 +23,15 @@ public static QueryStep forSelect(
 			ColumnDateRange daterange,
 			SqlSelect select,
 			SqlTables tables,
-			DialectBundle dialectBundle
+			LegacyCompilerDialect compilerDialect
 	) {
 		List<QueryStep> predecessors = List.of(withAggregatedDaterange);
 		QueryStep directPredecessor = withAggregatedDaterange;
 
 		// we need an additional predecessor to unnest the validity date if it is a single column range
-		if (dialectBundle.supportsSingleColumnRanges()) {
+		if (compilerDialect.supportsSingleColumnRanges()) {
 			String unnestCteName = tables.cteName(ConceptCteStep.UNNEST_DATE);
-			directPredecessor = dialectBundle.getFunctionProvider().unnestDaterange(daterange, withAggregatedDaterange, unnestCteName);
+			directPredecessor = compilerDialect.getFunctionProvider().unnestDaterange(daterange, withAggregatedDaterange, unnestCteName);
 			predecessors = List.of(withAggregatedDaterange, directPredecessor);
 		}
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/JoinBranchesCte.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/JoinBranchesCte.java
index b2f6718dfd..4b467167d8 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/JoinBranchesCte.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/JoinBranchesCte.java
@@ -6,14 +6,14 @@
 
 import com.bakdata.conquery.sql.conversion.cqelement.intervalpacking.IntervalPackingContext;
 import com.bakdata.conquery.sql.conversion.dialect.IntervalPacker;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.ConqueryJoinType;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
 import com.bakdata.conquery.sql.conversion.model.QueryStepJoiner;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import com.bakdata.conquery.sql.conversion.model.aggregator.SumSqlAggregator;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import org.jooq.Record;
 import org.jooq.TableLike;
 
@@ -63,7 +63,7 @@ protected QueryStep.QueryStepBuilder convertStep(CQTableContext tableContext) {
 		}
 		else {
 			IntervalPackingContext intervalPackingContext = createIntervalPackingContext(tableContext);
-			IntervalPacker intervalPacker = tableContext.getConversionContext().getDialectBundle().getIntervalPacker();
+			IntervalPacker intervalPacker = tableContext.getConversionContext().getCompilerDialect().getIntervalPacker();
 			QueryStep lastIntervalPackingStep = intervalPacker.aggregateAsValidityDate(intervalPackingContext);
 			queriesToJoin.add(lastIntervalPackingStep);
 			validityDate = lastIntervalPackingStep.getQualifiedSelects().getValidityDate();
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/PreprocessingCte.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/PreprocessingCte.java
index 7556a1b869..78e16d7148 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/PreprocessingCte.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/PreprocessingCte.java
@@ -5,13 +5,13 @@
 import java.util.Optional;
 
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import com.bakdata.conquery.sql.conversion.model.filter.SqlFilters;
 import com.bakdata.conquery.sql.conversion.model.filter.WhereCondition;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import org.jooq.Condition;
 import org.jooq.Record;
 import org.jooq.Table;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/TablePath.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/TablePath.java
index 0ccbe64151..a021c2db28 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/TablePath.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/concept/TablePath.java
@@ -91,7 +91,7 @@ private static TablePathInfo collectConnectorTables(CQConcept cqConcept, CQTable
 
 		// interval packing requiredw
 		tableInfo.setContainsIntervalPacking(true);
-		tableInfo.addMappings(IntervalPackingCteStep.getMappings(PREPROCESSING, context.getDialectBundle()));
+		tableInfo.addMappings(IntervalPackingCteStep.getMappings(PREPROCESSING, context.getCompilerDialect()));
 
 		// validity date propagation not necessary
 		if (!cqConcept.isAggregateEventDates()) {
@@ -103,7 +103,7 @@ private static TablePathInfo collectConnectorTables(CQConcept cqConcept, CQTable
 		}
 
 		// interval packing selects required with optional unnest step
-		if (context.getDialectBundle().supportsSingleColumnRanges()) {
+		if (context.getCompilerDialect().supportsSingleColumnRanges()) {
 			tableInfo.addMappings(Map.of(
 					UNNEST_DATE, INTERVAL_COMPLETE,
 					INTERVAL_PACKING_SELECTS, UNNEST_DATE
@@ -135,7 +135,7 @@ private TablePathInfo collectConceptTables(QueryStep predecessor) {
 		);
 
 		// universal event date selects required with optional additional unnest step
-		if (context.getDialectBundle().supportsSingleColumnRanges()) {
+		if (context.getCompilerDialect().supportsSingleColumnRanges()) {
 			tableInfo.addRootTableMapping(UNNEST_DATE);
 			tableInfo.addMappings(Map.of(INTERVAL_PACKING_SELECTS, UNNEST_DATE));
 		}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/AggregationMode.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/AggregationMode.java
index 45e6f3b03f..4592d34294 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/AggregationMode.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/AggregationMode.java
@@ -1,7 +1,7 @@
 package com.bakdata.conquery.sql.conversion.cqelement.intervalpacking;
 
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 
 /**
  * Determines if the date that is getting interval-packed is stored as validity date of {@link Selects} or as arbitrary {@link SqlSelect}.
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/AnsiSqlIntervalPacker.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/AnsiSqlIntervalPacker.java
index 178136ea1a..d9c0ab1146 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/AnsiSqlIntervalPacker.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/AnsiSqlIntervalPacker.java
@@ -7,13 +7,13 @@
 import java.util.Optional;
 
 import com.bakdata.conquery.sql.conversion.dialect.IntervalPacker;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
-import com.bakdata.conquery.sql.conversion.model.QualifyingUtil;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.QualifyingUtil;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import lombok.RequiredArgsConstructor;
 import org.jooq.Field;
 import org.jooq.impl.DSL;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/IntervalPackingContext.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/IntervalPackingContext.java
index d644a635e9..a869876b32 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/IntervalPackingContext.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/IntervalPackingContext.java
@@ -7,12 +7,12 @@
 
 import com.bakdata.conquery.sql.conversion.Context;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
-import com.bakdata.conquery.sql.conversion.dialect.DialectBundle;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.conversion.dialect.LegacyCompilerDialect;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import com.bakdata.conquery.sql.conversion.model.SqlTables;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import lombok.Builder;
 import lombok.Value;
 
@@ -45,8 +45,8 @@ public class IntervalPackingContext implements Context {
 	ConversionContext conversionContext;
 
 	@Override
-	public DialectBundle getDialectBundle() {
-		return getConversionContext().getDialectBundle();
+	public LegacyCompilerDialect getCompilerDialect() {
+		return getConversionContext().getCompilerDialect();
 	}
 
 }
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/IntervalPackingCteStep.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/IntervalPackingCteStep.java
index ef5d068653..640e6b789d 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/IntervalPackingCteStep.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/IntervalPackingCteStep.java
@@ -5,7 +5,7 @@
 import java.util.Set;
 
 import com.bakdata.conquery.sql.conversion.Context;
-import com.bakdata.conquery.sql.conversion.dialect.DialectBundle;
+import com.bakdata.conquery.sql.conversion.dialect.LegacyCompilerDialect;
 import com.bakdata.conquery.sql.conversion.model.CteStep;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
 import com.bakdata.conquery.sql.conversion.model.SqlTables;
@@ -31,7 +31,7 @@ public enum IntervalPackingCteStep implements CteStep {
 	public static SqlTables createTables(QueryStep predecessor, Context context) {
 
 		String rootTable = predecessor.getCteName();
-		Set<CteStep> requiredSteps = context.getDialectBundle().supportsSingleColumnRanges()
+		Set<CteStep> requiredSteps = context.getCompilerDialect().supportsSingleColumnRanges()
 									 ? Set.of(INTERVAL_COMPLETE)
 									 : Set.of(values());
 
@@ -45,7 +45,7 @@ public static SqlTables createTables(QueryStep predecessor, Context context) {
 	 * Create predecessor mappings for these interval packing {@link CteStep}s based on a preceding root step that must contain a validity date which
 	 * shall be interval-packed.
 	 */
-	public static Map<CteStep, CteStep> getMappings(CteStep root, DialectBundle dialect) {
+	public static Map<CteStep, CteStep> getMappings(CteStep root, LegacyCompilerDialect dialect) {
 		if (dialect.supportsSingleColumnRanges()) {
 			return Map.of(INTERVAL_COMPLETE, root);
 		}
@@ -57,7 +57,7 @@ public static Map<CteStep, CteStep> getMappings(CteStep root, DialectBundle dial
 	/**
 	 * Create predecessor mappings for these interval packing {@link CteStep}s based on the default mapping.
 	 */
-	public static Map<CteStep, CteStep> getMappings(DialectBundle dialect) {
+	public static Map<CteStep, CteStep> getMappings(LegacyCompilerDialect dialect) {
 		if (dialect.supportsSingleColumnRanges()) {
 			Map<CteStep, CteStep> mappings = new HashMap<>();
 			mappings.put(INTERVAL_COMPLETE, null); // final step directly mapped onto root table
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/IntervalPackingResult.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/IntervalPackingResult.java
index c8e71a3166..68134c0dc7 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/IntervalPackingResult.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/IntervalPackingResult.java
@@ -1,6 +1,6 @@
 package com.bakdata.conquery.sql.conversion.cqelement.intervalpacking;
 
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
 import lombok.Value;
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/PostgreSqlIntervalPacker.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/PostgreSqlIntervalPacker.java
index 8fae49bdb8..26071551b0 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/PostgreSqlIntervalPacker.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/intervalpacking/PostgreSqlIntervalPacker.java
@@ -4,10 +4,10 @@
 
 import com.bakdata.conquery.sql.conversion.dialect.IntervalPacker;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import lombok.RequiredArgsConstructor;
 
 /**
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/DialectBundle.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/DialectBundle.java
index d0596962c3..1e38a3ab88 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/DialectBundle.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/DialectBundle.java
@@ -1,120 +1,32 @@
 package com.bakdata.conquery.sql.conversion.dialect;
 
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
 import com.bakdata.conquery.models.config.ConqueryConfig;
 import com.bakdata.conquery.models.config.Dialect;
-import com.bakdata.conquery.models.datasets.concepts.select.Select;
 import com.bakdata.conquery.models.events.MajorTypeId;
-import com.bakdata.conquery.models.query.Visitable;
-import com.bakdata.conquery.sql.conversion.Converter;
-import com.bakdata.conquery.sql.conversion.NodeConverter;
-import com.bakdata.conquery.sql.conversion.cqelement.CQAndConverter;
-import com.bakdata.conquery.sql.conversion.cqelement.CQDateRestrictionConverter;
-import com.bakdata.conquery.sql.conversion.cqelement.CQExternalConverter;
-import com.bakdata.conquery.sql.conversion.cqelement.CQNegationConverter;
-import com.bakdata.conquery.sql.conversion.cqelement.CQOrConverter;
-import com.bakdata.conquery.sql.conversion.cqelement.CQYesConverter;
-import com.bakdata.conquery.sql.conversion.cqelement.concept.CQConceptConverter;
-import com.bakdata.conquery.sql.conversion.forms.StratificationFunctions;
-import com.bakdata.conquery.sql.conversion.model.QueryStepTransformer;
-import com.bakdata.conquery.sql.conversion.model.select.SelectConverter;
-import com.bakdata.conquery.sql.conversion.query.AbsoluteFormQueryConverter;
-import com.bakdata.conquery.sql.conversion.query.CQReusedQueryConverter;
-import com.bakdata.conquery.sql.conversion.query.ConceptQueryConverter;
-import com.bakdata.conquery.sql.conversion.query.EntityDateQueryConverter;
-import com.bakdata.conquery.sql.conversion.query.FormConversionHelper;
-import com.bakdata.conquery.sql.conversion.query.RelativFormQueryConverter;
-import com.bakdata.conquery.sql.conversion.query.SecondaryIdQueryConverter;
-import com.bakdata.conquery.sql.conversion.query.TableExportQueryConverter;
 import com.bakdata.conquery.sql.execution.ResultSetProcessor;
-import com.bakdata.conquery.sql.execution.SqlCDateSetParser;
-import org.jooq.DSLContext;
 import org.jooq.Field;
 import org.jooq.SQLDialect;
 
-public interface DialectBundle {
-
-	private static <R, C extends Converter<?, R, ?>> List<C> customize(List<C> defaults, List<C> substitutes) {
-		Map<Class<?>, C> substituteMap = getSubstituteMap(substitutes);
-		return defaults.stream()
-					   .map(converter -> substituteMap.getOrDefault(converter.getConversionClass(), converter))
-					   .toList();
-	}
-
-	private static <R, C extends Converter<?, R, ?>> Map<Class<?>, C> getSubstituteMap(List<C> substitutes) {
-		return substitutes.stream()
-						  .collect(Collectors.toMap(
-								  Converter::getConversionClass,
-								  Function.identity()
-						  ));
-	}
+/**
+ * Compatibility aggregate used when wiring all database-specific services for a backend namespace.
+ *
+ * <p>The bundle exposes both the legacy compiler adapter inherited from {@link LegacyCompilerDialect} and the runtime
+ * methods declared here. Legacy compiler code must depend on {@code LegacyCompilerDialect}, not on this aggregate.
+ * Runtime wiring may retain the bundle when it needs to construct both compiler and execution services for the same
+ * database.</p>
+ *
+ * <p>This interface keeps the existing HANA and ClickHouse integrations source-compatible while their compiler and
+ * execution capabilities are separated. It is an application composition boundary, not a compiler dependency.</p>
+ */
+public interface DialectBundle extends LegacyCompilerDialect {
 
 	ResultSetProcessor getResultSetProcessor(ConqueryConfig config);
 
 	Dialect getDialect();
 
-	int getNameMaxLength();
-
 	String getConnectionTestString();
 
 	SQLDialect getJooqDialect();
 
-
-	StratificationFunctions getStratificationFunctions();
-
 	boolean isTypeCompatible(Field<?> field, MajorTypeId type);
-
-	SqlFunctionProvider getFunctionProvider();
-
-	IntervalPacker getIntervalPacker();
-
-	SqlDateAggregator getDateAggregator();
-
-	List<NodeConverter<? extends Visitable>> getNodeConverters(DSLContext context);
-
-	default boolean supportsSingleColumnRanges() {
-		return false;
-	}
-
-	default List<NodeConverter<? extends Visitable>> getDefaultNodeConverters(DSLContext dslContext) {
-
-		QueryStepTransformer queryStepTransformer = new QueryStepTransformer(dslContext);
-		FormConversionHelper formConversionUtil = new FormConversionHelper(queryStepTransformer);
-
-		return List.of(
-				new CQDateRestrictionConverter(),
-				new CQAndConverter(),
-				new CQOrConverter(),
-				new CQNegationConverter(),
-				new CQYesConverter(),
-				new CQConceptConverter(),
-				new CQExternalConverter(),
-				new CQReusedQueryConverter(),
-				new ConceptQueryConverter(queryStepTransformer),
-				new SecondaryIdQueryConverter(),
-				new AbsoluteFormQueryConverter(formConversionUtil),
-				new EntityDateQueryConverter(formConversionUtil),
-				new RelativFormQueryConverter(formConversionUtil),
-				new TableExportQueryConverter(queryStepTransformer)
-		);
-	}
-
-	default Map<Class<? extends Select>, ? extends SelectConverter<? extends Select>> getSelectConverterOverrides(){
-		return Collections.emptyMap();
-	}
-
-	default SelectConverter<Select> getSelectConverter(Select select){
-		SelectConverter<Select> maybeOverride = (SelectConverter<Select>) getSelectConverterOverrides().get(select.getClass());
-
-		if (maybeOverride != null){
-			return maybeOverride;
-		}
-
-		return select.createConverter();
-	}
 }
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/IntervalPacker.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/IntervalPacker.java
index 84652c01a6..508487ba34 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/IntervalPacker.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/IntervalPacker.java
@@ -3,7 +3,7 @@
 
 import com.bakdata.conquery.sql.conversion.cqelement.intervalpacking.IntervalPackingContext;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 
 /**
  * Packing intervals involves packing groups of intersecting validity date intervals into their respective continuous intervals.
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/LegacyCompilerDialect.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/LegacyCompilerDialect.java
new file mode 100644
index 0000000000..b299373aa6
--- /dev/null
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/LegacyCompilerDialect.java
@@ -0,0 +1,104 @@
+package com.bakdata.conquery.sql.conversion.dialect;
+
+import java.sql.Date;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import com.bakdata.conquery.models.datasets.concepts.select.Select;
+import com.bakdata.conquery.models.query.Visitable;
+import com.bakdata.conquery.sql.compiler.dialect.CompilerDialect;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
+import com.bakdata.conquery.sql.conversion.NodeConverter;
+import com.bakdata.conquery.sql.conversion.cqelement.CQAndConverter;
+import com.bakdata.conquery.sql.conversion.cqelement.CQDateRestrictionConverter;
+import com.bakdata.conquery.sql.conversion.cqelement.CQExternalConverter;
+import com.bakdata.conquery.sql.conversion.cqelement.CQNegationConverter;
+import com.bakdata.conquery.sql.conversion.cqelement.CQOrConverter;
+import com.bakdata.conquery.sql.conversion.cqelement.CQYesConverter;
+import com.bakdata.conquery.sql.conversion.cqelement.concept.CQConceptConverter;
+import com.bakdata.conquery.sql.conversion.forms.StratificationFunctions;
+import com.bakdata.conquery.sql.conversion.model.QueryStepTransformer;
+import com.bakdata.conquery.sql.conversion.model.select.SelectConverter;
+import com.bakdata.conquery.sql.conversion.query.AbsoluteFormQueryConverter;
+import com.bakdata.conquery.sql.conversion.query.CQReusedQueryConverter;
+import com.bakdata.conquery.sql.conversion.query.ConceptQueryConverter;
+import com.bakdata.conquery.sql.conversion.query.EntityDateQueryConverter;
+import com.bakdata.conquery.sql.conversion.query.FormConversionHelper;
+import com.bakdata.conquery.sql.conversion.query.RelativFormQueryConverter;
+import com.bakdata.conquery.sql.conversion.query.SecondaryIdQueryConverter;
+import com.bakdata.conquery.sql.conversion.query.TableExportQueryConverter;
+import org.jooq.DSLContext;
+import org.jooq.Field;
+
+/**
+ * Temporary backend adapter exposing services required by the legacy SQL compiler.
+ *
+ * <p>The framework-neutral dialect contract lives in {@link CompilerDialect}. This adapter retains dependencies on
+ * backend query DTOs, converter registries, and legacy compiler services until those implementations move into the SQL
+ * connector. New connector code must not depend on this interface.</p>
+ */
+public interface LegacyCompilerDialect extends CompilerDialect {
+
+	@Override
+	default <T> Field<T> anyValue(Field<T> field) {
+		return getFunctionProvider().anyValue(field);
+	}
+
+	@Override
+	default Field<?> renderDateRange(Field<Date> start, Field<Date> end) {
+		return getFunctionProvider().dateRangeToField(ColumnDateRange.of(start, end));
+	}
+
+	@Override
+	default Field<?> aggregateDateRanges(Field<Date> start, Field<Date> end) {
+		return getFunctionProvider().dateRangeAggregation(ColumnDateRange.of(start, end));
+	}
+
+	StratificationFunctions getStratificationFunctions();
+
+	SqlFunctionProvider getFunctionProvider();
+
+	IntervalPacker getIntervalPacker();
+
+	SqlDateAggregator getDateAggregator();
+
+	List<NodeConverter<? extends Visitable>> getNodeConverters(DSLContext context);
+
+	default List<NodeConverter<? extends Visitable>> getDefaultNodeConverters(DSLContext dslContext) {
+
+		QueryStepTransformer queryStepTransformer = new QueryStepTransformer(dslContext);
+		FormConversionHelper formConversionUtil = new FormConversionHelper(queryStepTransformer);
+
+		return List.of(
+				new CQDateRestrictionConverter(),
+				new CQAndConverter(),
+				new CQOrConverter(),
+				new CQNegationConverter(),
+				new CQYesConverter(),
+				new CQConceptConverter(),
+				new CQExternalConverter(),
+				new CQReusedQueryConverter(),
+				new ConceptQueryConverter(queryStepTransformer),
+				new SecondaryIdQueryConverter(),
+				new AbsoluteFormQueryConverter(formConversionUtil),
+				new EntityDateQueryConverter(formConversionUtil),
+				new RelativFormQueryConverter(formConversionUtil),
+				new TableExportQueryConverter(queryStepTransformer)
+		);
+	}
+
+	default Map<Class<? extends Select>, ? extends SelectConverter<? extends Select>> getSelectConverterOverrides() {
+		return Collections.emptyMap();
+	}
+
+	default SelectConverter<Select> getSelectConverter(Select select) {
+		SelectConverter<Select> maybeOverride = (SelectConverter<Select>) getSelectConverterOverrides().get(select.getClass());
+
+		if (maybeOverride != null) {
+			return maybeOverride;
+		}
+
+		return select.createConverter();
+	}
+}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/SqlDateAggregator.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/SqlDateAggregator.java
index 175ca894a5..07a4ab1334 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/SqlDateAggregator.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/SqlDateAggregator.java
@@ -5,9 +5,9 @@
 import com.bakdata.conquery.models.query.queryplan.DateAggregationAction;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
 import com.bakdata.conquery.sql.conversion.cqelement.aggregation.DateAggregationDates;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 
 public interface SqlDateAggregator {
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/SqlFunctionProvider.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/SqlFunctionProvider.java
index 0a2b1552fd..d6a0871129 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/SqlFunctionProvider.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/SqlFunctionProvider.java
@@ -16,8 +16,8 @@
 import com.bakdata.conquery.models.datasets.concepts.DaterangeSelectOrFilter;
 import com.bakdata.conquery.models.datasets.concepts.ValidityDate;
 import com.bakdata.conquery.models.identifiable.ids.specific.ColumnId;
-import com.bakdata.conquery.sql.conversion.SharedAliases;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.SharedAliases;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
 import com.bakdata.conquery.sql.execution.ResultSetProcessor;
 import org.jooq.Condition;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/clickhouse/ClickhouseDistinctSelectConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/clickhouse/ClickhouseDistinctSelectConverter.java
index fb6ddc89a4..1c6c77cf4d 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/clickhouse/ClickhouseDistinctSelectConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/clickhouse/ClickhouseDistinctSelectConverter.java
@@ -7,10 +7,10 @@
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConceptCteStep;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConnectorSqlTables;
 import com.bakdata.conquery.sql.conversion.model.select.ConnectorSqlSelects;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
 import com.bakdata.conquery.sql.conversion.model.select.SelectContext;
 import com.bakdata.conquery.sql.conversion.model.select.SelectConverter;
-import com.bakdata.conquery.sql.conversion.model.select.SingleColumnSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SingleColumnSqlSelect;
 
 public class ClickhouseDistinctSelectConverter implements SelectConverter<DistinctSelect> {
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/clickhouse/ClickhouseFunctionProvider.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/clickhouse/ClickhouseFunctionProvider.java
index 0131145f01..d7dde0cb09 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/clickhouse/ClickhouseFunctionProvider.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/clickhouse/ClickhouseFunctionProvider.java
@@ -13,7 +13,7 @@
 import com.bakdata.conquery.models.datasets.concepts.DaterangeSelectOrFilter;
 import com.bakdata.conquery.models.datasets.concepts.ValidityDate;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
 import org.jetbrains.annotations.NotNull;
 import org.jooq.Condition;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/clickhouse/ClickhouseStratificationFunctions.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/clickhouse/ClickhouseStratificationFunctions.java
index 3126dcae20..1066555a3f 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/clickhouse/ClickhouseStratificationFunctions.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/clickhouse/ClickhouseStratificationFunctions.java
@@ -13,7 +13,7 @@
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
 import com.bakdata.conquery.sql.conversion.forms.Offset;
 import com.bakdata.conquery.sql.conversion.forms.StratificationFunctions;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import org.jooq.Field;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/hana/HanaSqlFunctionProvider.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/hana/HanaSqlFunctionProvider.java
index cc2fdb4a7e..a885d8c478 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/hana/HanaSqlFunctionProvider.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/hana/HanaSqlFunctionProvider.java
@@ -16,7 +16,7 @@
 import com.bakdata.conquery.models.datasets.concepts.DaterangeSelectOrFilter;
 import com.bakdata.conquery.models.datasets.concepts.ValidityDate;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
 import org.jetbrains.annotations.NotNull;
 import org.jooq.Condition;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/hana/HanaStratificationFunctions.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/hana/HanaStratificationFunctions.java
index 2bae80d371..cc82c62fee 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/hana/HanaStratificationFunctions.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/hana/HanaStratificationFunctions.java
@@ -9,7 +9,7 @@
 import com.bakdata.conquery.sql.conversion.dialect.Interval;
 import com.bakdata.conquery.sql.conversion.forms.Offset;
 import com.bakdata.conquery.sql.conversion.forms.StratificationFunctions;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import org.jooq.Field;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/AbsoluteStratification.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/AbsoluteStratification.java
index 190aa2c512..99a633eff8 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/AbsoluteStratification.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/AbsoluteStratification.java
@@ -9,13 +9,13 @@
 
 import com.bakdata.conquery.apiv1.forms.export_form.ExportForm;
 import com.bakdata.conquery.models.forms.util.Resolution;
-import com.bakdata.conquery.sql.conversion.SharedAliases;
+import com.bakdata.conquery.sql.compiler.ir.SharedAliases;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
 import com.google.common.base.Preconditions;
 import lombok.RequiredArgsConstructor;
 import org.jooq.Condition;
@@ -118,7 +118,7 @@ private QueryStep createCompleteTable() {
 		// complete range shall have a null index because it spans the complete range, but we set it to 1 to ensure we can join tables on index,
 		// because a condition involving null in a join (e.g., null = some_value or null = null) always evaluates to false
 		Field<Integer> index = field(inline(1)).as(SharedAliases.INDEX.getAlias());
-		SqlIdColumns ids = baseStepSelects.getIds().withAbsoluteStratification(Resolution.COMPLETE, index);
+		SqlIdColumns ids = baseStepSelects.getIds().withStratification(Resolution.COMPLETE.name(), index);
 
 		ColumnDateRange completeRange = baseStepSelects.getStratificationDate().get();
 
@@ -146,7 +146,7 @@ private QueryStep createIntervalTable(QueryStep indexStartStep, ExportForm.Resol
 		);
 
 		Field<Integer> index = stratificationFunctions.index(countsCteSelects.getIds(), countsCte.getQualifiedSelects().getStratificationDate());
-		SqlIdColumns ids = countsCteSelects.getIds().withAbsoluteStratification(resolutionAndAlignment.getResolution(), index);
+		SqlIdColumns ids = countsCteSelects.getIds().withStratification(resolutionAndAlignment.getResolution().name(), index);
 
 		Selects selects = Selects.builder()
 								 .ids(ids)
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/FormConstants.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/FormConstants.java
index e51fe3e87f..38984a7cb3 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/FormConstants.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/FormConstants.java
@@ -5,7 +5,7 @@
 import com.bakdata.conquery.apiv1.query.TemporalSamplerFactory;
 import com.bakdata.conquery.models.forms.managed.AbsoluteFormQuery;
 import com.bakdata.conquery.models.forms.managed.EntityDateQuery;
-import com.bakdata.conquery.sql.conversion.SharedAliases;
+import com.bakdata.conquery.sql.compiler.ir.SharedAliases;
 import org.jooq.Field;
 import org.jooq.impl.DSL;
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/RelativeStratification.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/RelativeStratification.java
index d06755cbdc..0961d6fbc8 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/RelativeStratification.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/RelativeStratification.java
@@ -18,15 +18,15 @@
 import com.bakdata.conquery.models.forms.managed.RelativeFormQuery;
 import com.bakdata.conquery.models.forms.util.CalendarUnit;
 import com.bakdata.conquery.models.forms.util.Resolution;
-import com.bakdata.conquery.sql.conversion.SharedAliases;
+import com.bakdata.conquery.sql.compiler.ir.SharedAliases;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
 import com.bakdata.conquery.sql.conversion.dialect.Interval;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
 import com.google.common.base.Preconditions;
 import lombok.RequiredArgsConstructor;
 import org.jooq.Field;
@@ -163,20 +163,20 @@ private QueryStep createCompleteTable(QueryStep totalBoundsStep, RelativeFormQue
 				Stream.concat(Stream.ofNullable(outcomeTable), Stream.ofNullable(featureTable)).toList(),
 				FormCteStep.COMPLETE.getSuffix(),
 				Collections.emptyList(),
-				context.isNegation(), functionProvider
+				context.isNegation()
 		);
 	}
 
 	private QueryStep createCompleteFeatureTable(Selects predecessorSelects, Interval interval, Range<Integer> intRange, QueryStep totalBoundsStep) {
 		Field<Integer> featureIndex = DSL.field(DSL.inline(-1)).as(SharedAliases.INDEX.getAlias());
-		SqlIdColumns featureIds = predecessorSelects.getIds().withRelativeStratification(Resolution.COMPLETE, featureIndex, INDEX_SELECTOR);
+		SqlIdColumns featureIds = predecessorSelects.getIds().withStratification(Resolution.COMPLETE.name(), featureIndex, INDEX_SELECTOR);
 		Field<Date> rangeStart = stratificationFunctions.shiftByInterval(INDEX_START_NEGATIVE, interval, DSL.inline(intRange.getMin()), Offset.NONE);
 		return createIntervalStep(featureIds, rangeStart, INDEX_START_NEGATIVE, Optional.empty(), totalBoundsStep);
 	}
 
 	private QueryStep createCompleteOutcomeTable(Selects predecessorSelects, Interval interval, Range<Integer> intRange, QueryStep totalBoundsStep) {
 		Field<Integer> outcomeIndex = DSL.field(DSL.inline(1)).as(SharedAliases.INDEX.getAlias());
-		SqlIdColumns outcomeIds = predecessorSelects.getIds().withRelativeStratification(Resolution.COMPLETE, outcomeIndex, INDEX_SELECTOR);
+		SqlIdColumns outcomeIds = predecessorSelects.getIds().withStratification(Resolution.COMPLETE.name(), outcomeIndex, INDEX_SELECTOR);
 		Field<Date> rangeEnd = stratificationFunctions.shiftByInterval(INDEX_START_POSITIVE, interval, DSL.inline(intRange.getMax()), Offset.NONE);
 		return createIntervalStep(outcomeIds, INDEX_START_POSITIVE, rangeEnd, Optional.empty(), totalBoundsStep);
 	}
@@ -185,7 +185,7 @@ private QueryStep createIntervalTable(QueryStep totalBoundsStep, Resolution reso
 
 		Field<Integer> seriesIndex = stratificationFunctions.intSeriesField();
 		Selects predecessorSelects = totalBoundsStep.getQualifiedSelects();
-		SqlIdColumns ids = predecessorSelects.getIds().withRelativeStratification(resolution, seriesIndex, INDEX_SELECTOR);
+		SqlIdColumns ids = predecessorSelects.getIds().withStratification(resolution.name(), seriesIndex, INDEX_SELECTOR);
 		Interval interval = getInterval(form.getTimeUnit(), resolution);
 		Range<Integer> bounds = toGenerateSeriesBounds(form, resolution);
 
@@ -196,7 +196,7 @@ private QueryStep createIntervalTable(QueryStep totalBoundsStep, Resolution reso
 				List.of(timeBeforeStep, timeAfterStep),
 				FormCteStep.stratificationCte(resolution).getSuffix(),
 				Collections.emptyList(),
-				context.isNegation(), functionProvider
+				context.isNegation()
 		);
 	}
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/StratificationFunctions.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/StratificationFunctions.java
index 1a2478b4f1..2b56a34f1e 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/StratificationFunctions.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/StratificationFunctions.java
@@ -26,11 +26,11 @@
 import com.bakdata.conquery.apiv1.forms.export_form.ExportForm;
 import com.bakdata.conquery.apiv1.query.TemporalSamplerFactory;
 import com.bakdata.conquery.models.forms.util.CalendarUnit;
-import com.bakdata.conquery.sql.conversion.SharedAliases;
+import com.bakdata.conquery.sql.compiler.ir.SharedAliases;
 import com.bakdata.conquery.sql.conversion.dialect.Interval;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import org.jooq.Condition;
 import org.jooq.Field;
 import org.jooq.Record;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/StratificationTableFactory.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/StratificationTableFactory.java
index 4287a5ace8..046f300e3d 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/StratificationTableFactory.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/forms/StratificationTableFactory.java
@@ -55,7 +55,7 @@ protected static QueryStep unionResolutionTables(List<QueryStep> unionSteps, Lis
 				withQualifiedSelects,
 				FormCteStep.FULL_STRATIFICATION.getSuffix(),
 				Stream.concat(predecessors.stream(), unionSteps.stream()).toList(),
-				context.isNegation(), context.getFunctionProvider()
+				context.isNegation()
 		);
 	}
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/ColumnDateRange.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/ColumnDateRange.java
deleted file mode 100644
index f8679840ce..0000000000
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/ColumnDateRange.java
+++ /dev/null
@@ -1,99 +0,0 @@
-package com.bakdata.conquery.sql.conversion.model;
-
-import java.sql.Date;
-import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
-import lombok.Getter;
-import lombok.ToString;
-import org.jooq.Condition;
-import org.jooq.Field;
-import org.jooq.impl.DSL;
-
-//TODO split this class up into Dialect specific versions.
-@Getter
-@ToString(onlyExplicitlyIncluded = true)
-public class ColumnDateRange implements SqlSelect {
-
-	private static final String VALIDITY_DATE_COLUMN_NAME_SUFFIX = "_validity_date";
-	private static final String START_SUFFIX = "_start";
-	private static final String END_SUFFIX = "_end";
-
-	@ToString.Include
-	private final Field<Date> start;
-	@ToString.Include
-	private final Field<Date> end;
-	private final String alias;
-
-	protected ColumnDateRange(Field<Date> startColumn, Field<Date> endColumn, String alias) {
-		start = startColumn;
-		end = endColumn;
-		this.alias = alias;
-	}
-
-	public static ColumnDateRange of(Field<Date> startColumn, Field<Date> endColumn) {
-		return new ColumnDateRange(startColumn, endColumn, "");
-	}
-
-	public static ColumnDateRange of(Field<Date> startColumn, Field<Date> endColumn, String alias) {
-		return new ColumnDateRange(startColumn, endColumn, alias);
-	}
-
-
-	public ColumnDateRange asValidityDateRange(String alias) {
-		return as(alias + VALIDITY_DATE_COLUMN_NAME_SUFFIX);
-	}
-
-	@Override
-	public List<Field<?>> toFields() {
-		return Stream.of(start, end)
-					 .collect(Collectors.toList());
-	}
-
-	@Override
-	public ColumnDateRange qualify(String qualifier) {
-		return new ColumnDateRange(
-				QualifyingUtil.qualify(getStart(), qualifier),
-				QualifyingUtil.qualify(getEnd(), qualifier),
-				getAlias()
-		);
-	}
-
-	@Override
-	public List<String> requiredColumns() {
-		return toFields().stream()
-				.map(Field::getName)
-				.distinct()
-				.toList();
-	}
-
-	public ColumnDateRange as(String alias) {
-		return new ColumnDateRange(
-				start.as(alias + START_SUFFIX),
-				end.as(alias + END_SUFFIX),
-				alias
-		);
-	}
-
-	public ColumnDateRange coalesce(ColumnDateRange right) {
-		return ColumnDateRange.of(
-				DSL.coalesce(start, right.getStart()),
-				DSL.coalesce(end, right.getEnd())
-		).as(alias);
-	}
-
-	public Condition join(ColumnDateRange right) {
-		return start.eq(right.getStart()).and(end.eq(right.getEnd()));
-	}
-
-	public Condition isNotNull() {
-		return start.isNotNull().and(end.isNotNull());
-	}
-
-	public static Condition isNotEmpty(ColumnDateRange columnDateRange) {
-		return columnDateRange.getStart().isNotNull().and(columnDateRange.getEnd().isNotNull());
-	}
-
-}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/Qualifiable.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/Qualifiable.java
deleted file mode 100644
index a5c54fa5e2..0000000000
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/Qualifiable.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package com.bakdata.conquery.sql.conversion.model;
-
-public interface Qualifiable<T> {
-
-	T qualify(String qualifier);
-
-}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/QueryStep.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/QueryStep.java
index ee3d96bcde..9e12193867 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/QueryStep.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/QueryStep.java
@@ -1,7 +1,7 @@
 package com.bakdata.conquery.sql.conversion.model;
 
-import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import lombok.Builder;
 import lombok.Singular;
 import lombok.Value;
@@ -62,15 +62,15 @@ public class QueryStep {
 	@Singular
 	List<QueryStep> predecessors;
 
-	public static QueryStep createUnionAllStep(List<QueryStep> unionSteps, String cteName, List<QueryStep> predecessors, boolean negation, SqlFunctionProvider functionProvider) {
-		return createUnionStep(unionSteps, cteName, predecessors, true, negation, functionProvider);
+	public static QueryStep createUnionAllStep(List<QueryStep> unionSteps, String cteName, List<QueryStep> predecessors, boolean negation) {
+		return createUnionStep(unionSteps, cteName, predecessors, true, negation);
 	}
 
-	public static QueryStep createUnionStep(List<QueryStep> unionSteps, String cteName, List<QueryStep> predecessors, boolean negation, SqlFunctionProvider functionProvider) {
-		return createUnionStep(unionSteps, cteName, predecessors, false, negation, functionProvider);
+	public static QueryStep createUnionStep(List<QueryStep> unionSteps, String cteName, List<QueryStep> predecessors, boolean negation) {
+		return createUnionStep(unionSteps, cteName, predecessors, false, negation);
 	}
 
-	private static QueryStep createUnionStep(List<QueryStep> unionSteps, String cteName, List<QueryStep> predecessors, boolean unionAll, boolean negation, SqlFunctionProvider functionProvider) {
+	private static QueryStep createUnionStep(List<QueryStep> unionSteps, String cteName, List<QueryStep> predecessors, boolean unionAll, boolean negation) {
 		QueryStep first = unionSteps.getFirst();
 		return first.toBuilder()
 				.cteName(cteName)
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/QueryStepJoiner.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/QueryStepJoiner.java
index 79f1e6532e..cf69a12042 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/QueryStepJoiner.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/QueryStepJoiner.java
@@ -1,5 +1,6 @@
 package com.bakdata.conquery.sql.conversion.model;
 
+import com.bakdata.conquery.sql.compiler.ir.Selects;
 import static org.jooq.impl.DSL.*;
 
 import java.util.ArrayList;
@@ -13,12 +14,14 @@
 import com.bakdata.conquery.models.config.ColumnConfig;
 import com.bakdata.conquery.models.config.IdColumnConfig;
 import com.bakdata.conquery.models.query.queryplan.DateAggregationAction;
-import com.bakdata.conquery.sql.conversion.SharedAliases;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.SharedAliases;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
 import com.bakdata.conquery.sql.conversion.cqelement.aggregation.DateAggregationDates;
 import com.bakdata.conquery.sql.conversion.dialect.SqlDateAggregator;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
 import com.google.common.base.Preconditions;
 import org.jooq.Condition;
 import org.jooq.Field;
@@ -38,7 +41,7 @@ public class QueryStepJoiner {
 	 */
 	public static QueryStep antiJoinWithAllIdsTable(QueryStep queryStep, ConversionContext context, DateAggregationAction dateAggregationAction) {
 
-		SqlFunctionProvider functionProvider = context.getConversionContext().getDialectBundle().getFunctionProvider();
+		SqlFunctionProvider functionProvider = context.getConversionContext().getCompilerDialect().getFunctionProvider();
 
 		Field<String> queryStepPrimaryColumn = queryStep.getQualifiedSelects().getIds().getPrimaryColumn();
 		ColumnConfig idColumnConfig = context.getIdColumns().findPrimaryIdColumn();
@@ -190,7 +193,7 @@ private static QueryStep joinStepsContainingNegation(
 		}
 
 		// first, invert dates of negated step
-		SqlDateAggregator dateAggregator = context.getDialectBundle().getDateAggregator();
+		SqlDateAggregator dateAggregator = context.getCompilerDialect().getDateAggregator();
 		negateJoined = dateAggregator.invertAggregatedIntervals(negateJoined, context);
 
 		// join with all-ids table necessary
@@ -204,7 +207,7 @@ private static QueryStep joinStepsContainingNegation(
 		DateAggregationDates aggregationDates = DateAggregationDates.forValidityDates(List.of(
 				nonNegateJoined.getQualifiedSelects().getValidityDate(),
 				negateJoined.getQualifiedSelects().getValidityDate(),
-				Optional.of(context.getDialectBundle().getFunctionProvider().allRangeIf(infinityRangeCondition))
+				Optional.of(context.getCompilerDialect().getFunctionProvider().allRangeIf(infinityRangeCondition))
 		));
 		ColumnDateRange merged =
 				dateAggregator.getAggregatedValidityDate(aggregationDates, DateAggregationAction.MERGE)
@@ -326,7 +329,7 @@ private static QueryStep buildStepAndAggregateDates(
 		withAllValidityDates.addAll(dateAggregationDates.allStartsAndEnds());
 		QueryStep joinedStep = buildJoinedStep(ids, withAllValidityDates, Optional.empty(), Optional.empty(), builder);
 
-		SqlDateAggregator sqlDateAggregator = context.getDialectBundle().getDateAggregator();
+		SqlDateAggregator sqlDateAggregator = context.getCompilerDialect().getDateAggregator();
 		return sqlDateAggregator.apply(
 				joinedStep,
 				mergedSelects,
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/QueryStepTransformer.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/QueryStepTransformer.java
index fa34d101b0..cf838a39d3 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/QueryStepTransformer.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/QueryStepTransformer.java
@@ -1,6 +1,8 @@
 package com.bakdata.conquery.sql.conversion.model;
 
-import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
+import com.bakdata.conquery.sql.compiler.dialect.CompilerDialect;
+import com.bakdata.conquery.sql.compiler.rendering.SelectProjectionRenderer;
+import com.bakdata.conquery.sql.compiler.rendering.SelectProjectionRenderer.ValidityDateRendering;
 import lombok.RequiredArgsConstructor;
 import org.jooq.*;
 import org.jooq.Record;
@@ -20,11 +22,14 @@ public class QueryStepTransformer {
 	/**
 	 * Converts a given {@link QueryStep} into an executable SELECT statement.
 	 */
-	public Select<Record> toSelectQuery(QueryStep queryStep, SqlFunctionProvider functionProvider) {
+	public Select<Record> toSelectQuery(QueryStep queryStep, CompilerDialect dialect) {
 
-		List<Field<?>> finalRepresentation = queryStep.getSelects().toFinalRepresentation(functionProvider, queryStep.isForTableExport());
+		ValidityDateRendering validityDateRendering = queryStep.isForTableExport()
+				? ValidityDateRendering.INDIVIDUAL
+				: ValidityDateRendering.AGGREGATED;
+		List<Field<?>> finalRepresentation = SelectProjectionRenderer.render(queryStep.getSelects(), dialect, validityDateRendering);
 
-		SelectConditionStep<Record> queryBase = this.dslContext.with(constructPredecessorCteList(queryStep, functionProvider))
+		SelectConditionStep<Record> queryBase = this.dslContext.with(constructPredecessorCteList(queryStep, dialect))
 				.select(finalRepresentation)
 				.from(queryStep.getFromTables())
 				.where(queryStep.getConditions());
@@ -37,39 +42,41 @@ public Select<Record> toSelectQuery(QueryStep queryStep, SqlFunctionProvider fun
 
 		// union
 		if (queryStep.isUnion()) {
-			return union(queryStep, grouped, functionProvider);
+			return union(queryStep, grouped, dialect);
 		}
 
 		return grouped;
 	}
 
-	private List<CommonTableExpression<Record>> constructPredecessorCteList(QueryStep queryStep, SqlFunctionProvider functionProvider) {
-		return predecessorCtes(queryStep, functionProvider)
+	private List<CommonTableExpression<Record>> constructPredecessorCteList(QueryStep queryStep, CompilerDialect dialect) {
+		return predecessorCtes(queryStep, dialect)
 				.toList();
 	}
 
-	private List<CommonTableExpression<Record>> toCteList(QueryStep queryStep, SqlFunctionProvider functionProvider) {
+	private List<CommonTableExpression<Record>> toCteList(QueryStep queryStep, CompilerDialect dialect) {
 		return Stream.concat(
-				this.predecessorCtes(queryStep, functionProvider),
-				Stream.of(toCte(queryStep, functionProvider))
+				this.predecessorCtes(queryStep, dialect),
+				Stream.of(toCte(queryStep, dialect))
 		).toList();
 	}
 
-	private Stream<CommonTableExpression<Record>> predecessorCtes(QueryStep queryStep, SqlFunctionProvider functionProvider) {
+	private Stream<CommonTableExpression<Record>> predecessorCtes(QueryStep queryStep, CompilerDialect dialect) {
 		return queryStep.getPredecessors().stream()
-				.flatMap(predecessor -> toCteList(predecessor, functionProvider).stream());
+				.flatMap(predecessor -> toCteList(predecessor, dialect).stream());
 	}
 
-	private CommonTableExpression<Record> toCte(QueryStep queryStep, SqlFunctionProvider functionProvider) {
-		Select<Record> selectStep = toSelectStep(queryStep, functionProvider);
+	private CommonTableExpression<Record> toCte(QueryStep queryStep, CompilerDialect dialect) {
+		Select<Record> selectStep = toSelectStep(queryStep, dialect);
 		return DSL.name(queryStep.getCteName()).as(selectStep);
 	}
 
-	private Select<Record> toSelectStep(QueryStep queryStep, SqlFunctionProvider functionProvider) {
+	private Select<Record> toSelectStep(QueryStep queryStep, CompilerDialect dialect) {
 
 		SelectSelectStep<Record> selectClause;
 
-		List<Field<?>> allSelects = queryStep.isForTableExport() ? queryStep.getSelects().toFinalRepresentation(functionProvider, true) : queryStep.getSelects().all();
+		List<Field<?>> allSelects = queryStep.isForTableExport()
+				? SelectProjectionRenderer.render(queryStep.getSelects(), dialect, ValidityDateRendering.INDIVIDUAL)
+				: queryStep.getSelects().all();
 
 		if (queryStep.isSelectDistinct()) {
 			selectClause = dslContext.selectDistinct(allSelects);
@@ -84,19 +91,19 @@ private Select<Record> toSelectStep(QueryStep queryStep, SqlFunctionProvider fun
 		}
 
 		if (queryStep.isUnion()) {
-			selectStep = union(queryStep, selectStep, functionProvider);
+			selectStep = union(queryStep, selectStep, dialect);
 		}
 
 		return selectStep;
 	}
 
-	private Select<Record> union(QueryStep queryStep, Select<Record> base, SqlFunctionProvider functionProvider) {
+	private Select<Record> union(QueryStep queryStep, Select<Record> base, CompilerDialect dialect) {
 		for (QueryStep unionStep : queryStep.getUnion()) {
 			Select<Record> selectStep =
 					queryStep.isForTableExport() ?
 							// TODO this feels like a leaked abstraction, but i am not able to find the proper injection layer at the moment.
-							toSelectQuery(unionStep, functionProvider) :
-							toSelectStep(unionStep, functionProvider);
+							toSelectQuery(unionStep, dialect) :
+							toSelectStep(unionStep, dialect);
 
 			if (queryStep.isUnionAll()) {
 				base = base.unionAll(selectStep);
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/Selects.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/Selects.java
deleted file mode 100644
index 160bae7711..0000000000
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/Selects.java
+++ /dev/null
@@ -1,114 +0,0 @@
-package com.bakdata.conquery.sql.conversion.model;
-
-import com.bakdata.conquery.models.datasets.concepts.select.Select;
-import com.bakdata.conquery.sql.conversion.SharedAliases;
-import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
-import lombok.Builder;
-import lombok.Singular;
-import lombok.Value;
-import org.jooq.Field;
-
-import java.util.List;
-import java.util.Optional;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-@Value
-@Builder(toBuilder = true)
-public class Selects {
-
-	SqlIdColumns ids;
-	@Builder.Default
-	Optional<ColumnDateRange> validityDate = Optional.empty();
-	@Builder.Default
-	Optional<ColumnDateRange> stratificationDate = Optional.empty();
-	@Singular
-	List<SqlSelect> sqlSelects;
-
-	public List<Field<?>> toFinalRepresentation(SqlFunctionProvider functionProvider, boolean forTableExport) {
-
-		final Optional<Field<?>> validityDateRendered =
-				!forTableExport
-						? getValidityDate().map(vdd -> functionProvider.dateRangeAggregation(vdd).as(SharedAliases.DATES_COLUMN.getAlias()))
-						: getValidityDate().map(vdd -> functionProvider.dateRangeToField(vdd).as(SharedAliases.DATES_COLUMN.getAlias()));
-
-		final Optional<Field<?>> stratificationDateRendered = getStratificationDate().map(vdd -> functionProvider.dateRangeToField(vdd).as(SharedAliases.STRATIFICATION_BOUNDS.getAlias()));
-
-		return Stream.of(
-						getIds().toFields().stream(),
-						stratificationDateRendered.stream(),
-						validityDateRendered.stream(),
-						getSqlSelects().stream().flatMap(sqlSelect -> sqlSelect.toFinalRepresentation().toFields().stream())
-				)
-				.flatMap(Function.identity())
-				.map(select -> (Field<?>) select)
-				.distinct()
-				.collect(Collectors.toList());
-	}
-
-	public Selects blockValidityDate() {
-		return this.toBuilder()
-				.validityDate(Optional.empty())
-				.build();
-	}
-
-	public Selects qualify(String qualifier) {
-		SqlIdColumns ids = this.ids.qualify(qualifier);
-		List<SqlSelect> sqlSelects = this.sqlSelects.stream().map(sqlSelect -> sqlSelect.qualify(qualifier)).collect(Collectors.toList());
-
-		SelectsBuilder builder = Selects.builder()
-				.ids(ids)
-				.sqlSelects(sqlSelects);
-
-		if (this.validityDate.isPresent()) {
-			builder = builder.validityDate(this.validityDate.map(_validityDate -> _validityDate.qualify(qualifier)));
-		}
-
-		if (this.stratificationDate.isPresent()) {
-			builder = builder.stratificationDate(this.stratificationDate.map(_validityDate -> _validityDate.qualify(qualifier)));
-		}
-
-		return builder.build();
-	}
-
-	public List<Field<?>> all() {
-		return Stream.of(
-						this.ids.toFields().stream(),
-						this.stratificationDate.stream().flatMap(range -> range.toFields().stream()),
-						this.validityDate.stream().flatMap(range -> range.toFields().stream()),
-						this.sqlSelects.stream().flatMap(sqlSelect -> sqlSelect.toFields().stream())
-				)
-				.flatMap(Function.identity())
-				.map(select -> (Field<?>) select)
-				.distinct()
-				.collect(Collectors.toList());
-	}
-
-	/**
-	 * All {@link Select}s that have not been explicitly selected (IDs, validity/stratification dates).
-	 */
-	public List<Field<?>> nonExplicitSelects() {
-		return Stream.of(
-						this.ids.toFields().stream(),
-						this.stratificationDate.stream().flatMap(range -> range.toFields().stream()),
-						this.validityDate.stream().flatMap(range -> range.toFields().stream())
-				)
-				.flatMap(Function.identity())
-				.map(select -> (Field<?>) select)
-				.distinct()
-				.collect(Collectors.toList());
-	}
-
-	/**
-	 * All explicitly selected and converted {@link Select}s.
-	 */
-	public List<Field<?>> explicitSelects() {
-		return this.sqlSelects.stream()
-				.flatMap(sqlSelect -> sqlSelect.toFields().stream())
-				.distinct()
-				.collect(Collectors.toList());
-	}
-
-}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/SqlIdColumns.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/SqlIdColumns.java
deleted file mode 100644
index 99af726ccb..0000000000
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/SqlIdColumns.java
+++ /dev/null
@@ -1,163 +0,0 @@
-package com.bakdata.conquery.sql.conversion.model;
-
-import java.sql.Date;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import javax.annotation.Nullable;
-
-import com.bakdata.conquery.models.forms.util.Resolution;
-import com.bakdata.conquery.sql.conversion.SharedAliases;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.ToString;
-import lombok.experimental.SuperBuilder;
-import org.jooq.Condition;
-import org.jooq.Field;
-import org.jooq.impl.DSL;
-
-@SuperBuilder
-@AllArgsConstructor
-@ToString
-public class SqlIdColumns implements Qualifiable<SqlIdColumns> {
-
-	@Getter
-	private final Field<String> primaryColumn;
-
-	@Nullable
-	private final Field<String> secondaryId;
-
-	@Nullable
-	@ToString.Exclude
-	private final SqlIdColumns predecessor;
-
-	public SqlIdColumns(Field<String> primaryColumn, Field<String> secondaryId) {
-		this.primaryColumn = primaryColumn;
-		this.secondaryId = secondaryId;
-		this.predecessor = null;
-	}
-
-	public SqlIdColumns(Field<String> primaryColumn) {
-		this.primaryColumn = primaryColumn;
-		this.secondaryId = null;
-		this.predecessor = null;
-	}
-
-	public SqlIdColumns withAlias() {
-		if (this.secondaryId == null) {
-			return new SqlIdColumns(this.primaryColumn.as(SharedAliases.PRIMARY_COLUMN.getAlias()), null, this);
-		}
-		return new SqlIdColumns(
-				this.primaryColumn.as(SharedAliases.PRIMARY_COLUMN.getAlias()),
-				this.secondaryId.as(SharedAliases.SECONDARY_ID.getAlias()),
-				this
-		);
-	}
-
-	@Override
-	public SqlIdColumns qualify(String qualifier) {
-		Field<String> primaryColumn = QualifyingUtil.qualify(this.primaryColumn, qualifier);
-		if (secondaryId == null) {
-			return new SqlIdColumns(primaryColumn, null, this);
-		}
-		Field<String> secondaryId = QualifyingUtil.qualify(this.secondaryId, qualifier);
-		return new SqlIdColumns(primaryColumn, secondaryId, this);
-	}
-
-	public SqlIdColumns withAbsoluteStratification(Resolution resolution, Field<Integer> index) {
-		Field<String> resolutionField = DSL.inline(resolution.toString()).as(SharedAliases.RESOLUTION.getAlias());
-		return StratificationSqlIdColumns.builder()
-										 .primaryColumn(this.primaryColumn)
-										 .secondaryId(this.secondaryId)
-										 .resolution(resolutionField)
-										 .index(index)
-										 .eventDate(null)
-										 .build();
-	}
-
-	public SqlIdColumns withRelativeStratification(Resolution resolution, Field<Integer> index, Field<Date> eventDate) {
-		Field<String> resolutionField = DSL.inline(resolution.toString()).as(SharedAliases.RESOLUTION.getAlias());
-		return StratificationSqlIdColumns.builder()
-										 .primaryColumn(this.primaryColumn)
-										 .secondaryId(this.secondaryId)
-										 .resolution(resolutionField)
-										 .index(index)
-										 .eventDate(eventDate)
-										 .build();
-	}
-
-	public SqlIdColumns forFinalSelect() {
-		return this;
-	}
-
-	public Optional<Field<String>> getSecondaryId() {
-		return Optional.ofNullable(this.secondaryId);
-	}
-
-	public Optional<SqlIdColumns> getPredecessor() {
-		return Optional.ofNullable(this.predecessor);
-	}
-
-	public boolean isWithStratification() {
-		return false;
-	}
-
-	public List<Field<?>> toFields() {
-		if (getSecondaryId().isEmpty()){
-			return List.of(getPrimaryColumn());
-		}
-
-		return List.of(getPrimaryColumn(), getSecondaryId().get());
-	}
-
-	public List<Condition> join(SqlIdColumns rightIds) {
-
-		// always join on primary columns
-		Condition joinPrimariesCondition = primaryColumn.eq(rightIds.getPrimaryColumn());
-
-		// join on secondary IDs if both are present
-		Condition joinSecondaries = getSecondaryId()
-				.flatMap(leftSecondaryId -> rightIds.getSecondaryId().map(leftSecondaryId::eq))
-				.orElse(DSL.noCondition());
-
-		return List.of(joinPrimariesCondition, joinSecondaries);
-	}
-
-	public SqlIdColumns coalesce(List<SqlIdColumns> selectsIds) {
-
-		List<Field<String>> primaryColumns = new ArrayList<>();
-		List<Field<String>> secondaryIds = new ArrayList<>();
-
-		// add this ids
-		primaryColumns.add(this.primaryColumn);
-		getSecondaryId().ifPresent(secondaryIds::add);
-
-		// add all other ids to coalesce with
-		selectsIds.forEach(ids -> {
-			primaryColumns.add(ids.getPrimaryColumn());
-			ids.getSecondaryId().ifPresent(secondaryIds::add);
-		});
-
-		Field<String> coalescedPrimaryColumn = coalesceFields(primaryColumns, String.class).coerce(String.class).as(SharedAliases.PRIMARY_COLUMN.getAlias());
-		if (secondaryIds.isEmpty()) {
-			return new SqlIdColumns(coalescedPrimaryColumn);
-		}
-		Field<String> coalescedSecondaryIds = coalesceFields(secondaryIds, String.class).coerce(String.class).as(SharedAliases.SECONDARY_ID.getAlias());
-		return new SqlIdColumns(coalescedPrimaryColumn, coalescedSecondaryIds);
-	}
-
-
-	protected static <T> Field<T> coalesceFields(List<? extends Field<?>> fields, Class<T> type) {
-		Field<T> out = fields.getFirst().coerce(type);
-
-		for (int index = 1; index < fields.size(); index++) {
-			out = DSL.coalesce(out, fields.get(index).coerce(type));
-		}
-
-		return out;
-	}
-
-}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/StratificationSqlIdColumns.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/StratificationSqlIdColumns.java
deleted file mode 100644
index 678afefab5..0000000000
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/StratificationSqlIdColumns.java
+++ /dev/null
@@ -1,166 +0,0 @@
-package com.bakdata.conquery.sql.conversion.model;
-
-import java.sql.Date;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import javax.annotation.Nullable;
-
-import com.bakdata.conquery.models.forms.util.Resolution;
-import com.bakdata.conquery.sql.conversion.SharedAliases;
-import com.google.common.base.Preconditions;
-import lombok.Getter;
-import lombok.experimental.SuperBuilder;
-import org.jooq.Condition;
-import org.jooq.Field;
-import org.jooq.impl.DSL;
-
-@Getter
-@SuperBuilder
-class StratificationSqlIdColumns extends SqlIdColumns {
-
-	private final Field<String> resolution;
-
-	private final Field<Integer> index;
-
-	/**
-	 * Optional event date. Only set for relative forms.
-	 */
-	@Nullable
-	private final Field<Date> eventDate;
-
-	@Override
-	public SqlIdColumns qualify(String qualifier) {
-
-		Field<String> primaryColumn = QualifyingUtil.qualify(getPrimaryColumn(), qualifier);
-		Field<String> resolution = QualifyingUtil.qualify(this.resolution, qualifier);
-		Field<Integer> index = QualifyingUtil.qualify(this.index, qualifier);
-		Field<Date> eventDate = null;
-		if (this.eventDate != null) {
-			eventDate = QualifyingUtil.qualify(this.eventDate, qualifier);
-		}
-
-		return StratificationSqlIdColumns.builder()
-										 .primaryColumn(primaryColumn)
-										 .secondaryId(null)
-										 .resolution(resolution)
-										 .index(index)
-										 .eventDate(eventDate)
-										 .build();
-	}
-
-	/**
-	 * Replaces the integer value of the {@link Resolution#COMPLETE} with null values.
-	 */
-	@Override
-	public SqlIdColumns forFinalSelect() {
-
-		Field<Integer> withNulledCompleteIndex = DSL.when(
-															this.resolution.eq(DSL.inline(Resolution.COMPLETE.toString().toUpperCase())),
-															DSL.inline(null, Integer.class)
-													)
-													.otherwise(this.index)
-													.as(SharedAliases.INDEX.getAlias());
-
-		return StratificationSqlIdColumns.builder()
-										 .primaryColumn(getPrimaryColumn())
-										 .secondaryId(null)
-										 .resolution(this.resolution)
-										 .index(withNulledCompleteIndex)
-										 .eventDate(this.eventDate)
-										 .build();
-	}
-
-	@Override
-	public boolean isWithStratification() {
-		return true;
-	}
-
-	@Override
-	public List<Field<?>> toFields() {
-		return Stream.of(
-							 getPrimaryColumn(),
-							 this.resolution,
-							 this.index,
-							 this.eventDate
-					 )
-					 .filter(Objects::nonNull)
-					 .collect(Collectors.toList());
-	}
-
-	@Override
-	public List<Condition> join(SqlIdColumns rightIds) {
-
-		if (!rightIds.isWithStratification()) {
-			return super.join(rightIds);
-		}
-
-		StratificationSqlIdColumns rightStratificationIds = (StratificationSqlIdColumns) rightIds;
-		Condition joinResolutionAndIndex = this.resolution.eq(rightStratificationIds.getResolution()).and(this.index.eq(rightStratificationIds.getIndex()));
-
-		Condition joinEventDateCondition;
-		if (this.eventDate != null) {
-			joinEventDateCondition = this.eventDate.eq(rightStratificationIds.getEventDate());
-		}
-		else {
-			joinEventDateCondition = DSL.noCondition();
-		}
-
-		return Stream.concat(
-							 super.join(rightIds).stream(),
-							 Stream.of(joinResolutionAndIndex, joinEventDateCondition)
-					 )
-					 .toList();
-	}
-
-	@Override
-	public SqlIdColumns coalesce(List<SqlIdColumns> selectsIds) {
-
-		Preconditions.checkArgument(
-				selectsIds.stream().allMatch(SqlIdColumns::isWithStratification),
-				"Can only coalesce SqlIdColumns if all are with stratification"
-		);
-
-		List<Field<String>> primaryColumns = new ArrayList<>();
-		List<Field<String>> resolutions = new ArrayList<>();
-		List<Field<Integer>> indices = new ArrayList<>();
-		List<Field<?>> eventDates = new ArrayList<>();
-
-		// add this ids
-		primaryColumns.add(getPrimaryColumn());
-		resolutions.add(this.resolution);
-		indices.add(this.index);
-		if (this.eventDate != null) {
-			eventDates.add(this.eventDate);
-		}
-
-		for (SqlIdColumns ids : selectsIds) {
-			StratificationSqlIdColumns stratificationIds = (StratificationSqlIdColumns) ids;
-			primaryColumns.add(stratificationIds.getPrimaryColumn());
-			resolutions.add(stratificationIds.getResolution());
-			indices.add(stratificationIds.getIndex());
-			if (stratificationIds.getEventDate() != null) {
-				eventDates.add(stratificationIds.getEventDate());
-			}
-		}
-
-		Field<String> coalescedPrimaryColumn = coalesceFields(primaryColumns, String.class).coerce(String.class).as(SharedAliases.PRIMARY_COLUMN.getAlias());
-		Field<String> coalescedResolutions = coalesceFields(resolutions, String.class).as(SharedAliases.RESOLUTION.getAlias());
-		Field<Integer> coalescedIndices = coalesceFields(indices, Integer.class).as(SharedAliases.INDEX.getAlias());
-		Field<Date> eventDate = null;
-		if (!eventDates.isEmpty()) {
-			eventDate = coalesceFields(eventDates, Date.class).as(SharedAliases.INDEX_SELECTOR.getAlias());
-		}
-
-		return StratificationSqlIdColumns.builder()
-										 .primaryColumn(coalescedPrimaryColumn)
-										 .secondaryId(null)
-										 .resolution(coalescedResolutions)
-										 .index(coalescedIndices)
-										 .eventDate(eventDate)
-										 .build();
-	}
-}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/CommonAggregationSelect.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/CommonAggregationSelect.java
index 20661511b9..c3d379b8fb 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/CommonAggregationSelect.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/CommonAggregationSelect.java
@@ -7,9 +7,9 @@
 import com.bakdata.conquery.models.datasets.concepts.select.Select;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
 import com.bakdata.conquery.sql.conversion.model.select.ConnectorSqlSelects;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
-import com.bakdata.conquery.sql.conversion.model.select.SingleColumnSqlSelect;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.SingleColumnSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import lombok.Builder;
 import lombok.Singular;
 import lombok.Value;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/CountQuartersSqlAggregator.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/CountQuartersSqlAggregator.java
index e0ebf555de..cc530f2d81 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/CountQuartersSqlAggregator.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/CountQuartersSqlAggregator.java
@@ -20,8 +20,8 @@
 import com.bakdata.conquery.sql.conversion.model.filter.SqlFilters;
 import com.bakdata.conquery.sql.conversion.model.filter.WhereClauses;
 import com.bakdata.conquery.sql.conversion.model.select.ConnectorSqlSelects;
-import com.bakdata.conquery.sql.conversion.model.select.ExtractingSqlSelect;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.ExtractingSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
 import com.bakdata.conquery.sql.conversion.model.select.SelectContext;
 import com.bakdata.conquery.sql.conversion.model.select.SelectConverter;
 import org.jooq.Condition;
@@ -111,7 +111,7 @@ public ConnectorSqlSelects connectorSelect(CountQuartersSelect countQuartersSele
 							   selectContext.getNameGenerator().selectName(countQuartersSelect),
 							   selectContext.getTables(),
 							   selectContext.getFunctionProvider(),
-							   selectContext.getDialectBundle().getStratificationFunctions()
+							   selectContext.getCompilerDialect().getStratificationFunctions()
 				);
 
 		String finalPredecessor = selectContext.getTables().getPredecessor(ConceptCteStep.AGGREGATION_FILTER);
@@ -134,7 +134,7 @@ public SqlFilters convertToSqlFilter(CountQuartersFilter countQuartersFilter, Fi
 							   filterContext.getNameGenerator().selectName(countQuartersFilter),
 							   filterContext.getTables(),
 							   filterContext.getFunctionProvider(),
-							   filterContext.getDialectBundle().getStratificationFunctions()
+							   filterContext.getCompilerDialect().getStratificationFunctions()
 				);
 
 		ConnectorSqlSelects selects = ConnectorSqlSelects.builder()
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/CountSqlAggregator.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/CountSqlAggregator.java
index b1bc5222e8..59bf61c842 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/CountSqlAggregator.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/CountSqlAggregator.java
@@ -12,8 +12,8 @@
 import com.bakdata.conquery.sql.conversion.model.filter.SqlFilters;
 import com.bakdata.conquery.sql.conversion.model.filter.WhereClauses;
 import com.bakdata.conquery.sql.conversion.model.select.ConnectorSqlSelects;
-import com.bakdata.conquery.sql.conversion.model.select.ExtractingSqlSelect;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.ExtractingSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
 import com.bakdata.conquery.sql.conversion.model.select.SelectContext;
 import com.bakdata.conquery.sql.conversion.model.select.SelectConverter;
 import lombok.NoArgsConstructor;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/DateDistanceSqlAggregator.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/DateDistanceSqlAggregator.java
index f540b01e41..3c8518d87e 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/DateDistanceSqlAggregator.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/DateDistanceSqlAggregator.java
@@ -5,12 +5,14 @@
 import com.bakdata.conquery.models.datasets.Column;
 import com.bakdata.conquery.models.datasets.concepts.filters.specific.DateDistanceFilter;
 import com.bakdata.conquery.models.datasets.concepts.select.connector.specific.DateDistanceSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.ExtractingSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConceptCteStep;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConnectorSqlTables;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.FilterContext;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.SqlTables;
 import com.bakdata.conquery.sql.conversion.model.filter.*;
 import com.bakdata.conquery.sql.conversion.model.select.*;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/DurationSumSqlAggregator.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/DurationSumSqlAggregator.java
index 93f9c41151..77cf07f83c 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/DurationSumSqlAggregator.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/DurationSumSqlAggregator.java
@@ -13,7 +13,7 @@
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConnectorSqlTables;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.FilterContext;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.filter.DateDistanceCondition;
 import com.bakdata.conquery.sql.conversion.model.filter.FilterConverter;
 import com.bakdata.conquery.sql.conversion.model.filter.SqlFilters;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/FlagSqlAggregator.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/FlagSqlAggregator.java
index a40af4eeda..056f8c3ebb 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/FlagSqlAggregator.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/FlagSqlAggregator.java
@@ -22,11 +22,11 @@
 import com.bakdata.conquery.sql.conversion.model.filter.SqlFilters;
 import com.bakdata.conquery.sql.conversion.model.filter.WhereClauses;
 import com.bakdata.conquery.sql.conversion.model.select.ConnectorSqlSelects;
-import com.bakdata.conquery.sql.conversion.model.select.ExtractingSqlSelect;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.ExtractingSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
 import com.bakdata.conquery.sql.conversion.model.select.SelectContext;
 import com.bakdata.conquery.sql.conversion.model.select.SelectConverter;
-import com.bakdata.conquery.sql.conversion.model.select.SingleColumnSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SingleColumnSqlSelect;
 import org.jooq.Condition;
 import org.jooq.Field;
 
@@ -137,7 +137,7 @@ private static List<Column> getRequiredColumns(Map<String, ColumnId> flags, Set<
 	@Override
 	public ConnectorSqlSelects connectorSelect(FlagSelect flagSelect, SelectContext<ConnectorSqlTables> selectContext) {
 
-		SqlFunctionProvider functionProvider = selectContext.getConversionContext().getDialectBundle().getFunctionProvider();
+		SqlFunctionProvider functionProvider = selectContext.getConversionContext().getCompilerDialect().getFunctionProvider();
 		SqlTables connectorTables = selectContext.getTables();
 
 		Map<String, SingleColumnSqlSelect> rootSelects = createFlagRootSelectMap(flagSelect, connectorTables.getRootTable());
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/SumSqlAggregator.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/SumSqlAggregator.java
index 80c74df4fa..94c3ffeb1a 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/SumSqlAggregator.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/aggregator/SumSqlAggregator.java
@@ -18,19 +18,19 @@
 import com.bakdata.conquery.sql.conversion.model.NameGenerator;
 import com.bakdata.conquery.sql.conversion.model.NumberMapUtil;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import com.bakdata.conquery.sql.conversion.model.SqlTables;
 import com.bakdata.conquery.sql.conversion.model.filter.FilterConverter;
 import com.bakdata.conquery.sql.conversion.model.filter.SqlFilters;
 import com.bakdata.conquery.sql.conversion.model.filter.SumCondition;
 import com.bakdata.conquery.sql.conversion.model.filter.WhereClauses;
 import com.bakdata.conquery.sql.conversion.model.select.ConnectorSqlSelects;
-import com.bakdata.conquery.sql.conversion.model.select.ExtractingSqlSelect;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.ExtractingSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
 import com.bakdata.conquery.sql.conversion.model.select.SelectContext;
 import com.bakdata.conquery.sql.conversion.model.select.SelectConverter;
-import com.bakdata.conquery.sql.conversion.model.select.SingleColumnSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SingleColumnSqlSelect;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import org.jooq.Condition;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/filter/AbstractSelectFilterConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/filter/AbstractSelectFilterConverter.java
index c43ae52ae9..ceae7497cf 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/filter/AbstractSelectFilterConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/filter/AbstractSelectFilterConverter.java
@@ -5,7 +5,7 @@
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConceptCteStep;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.FilterContext;
 import com.bakdata.conquery.sql.conversion.model.select.ConnectorSqlSelects;
-import com.bakdata.conquery.sql.conversion.model.select.ExtractingSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.ExtractingSqlSelect;
 import org.jooq.Condition;
 import org.jooq.Field;
 import org.jooq.impl.DSL;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/filter/DateRestrictionCondition.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/filter/DateRestrictionCondition.java
index 4a03e0dc94..387bd24608 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/filter/DateRestrictionCondition.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/filter/DateRestrictionCondition.java
@@ -1,7 +1,7 @@
 package com.bakdata.conquery.sql.conversion.model.filter;
 
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import lombok.RequiredArgsConstructor;
 import org.jooq.Condition;
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/filter/NumberFilterConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/filter/NumberFilterConverter.java
index f4e24084a2..5de7b72ab3 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/filter/NumberFilterConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/filter/NumberFilterConverter.java
@@ -7,7 +7,7 @@
 import com.bakdata.conquery.sql.conversion.cqelement.concept.FilterContext;
 import com.bakdata.conquery.sql.conversion.model.NumberMapUtil;
 import com.bakdata.conquery.sql.conversion.model.select.ConnectorSqlSelects;
-import com.bakdata.conquery.sql.conversion.model.select.ExtractingSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.ExtractingSqlSelect;
 import org.jooq.Condition;
 import org.jooq.Field;
 import org.jooq.impl.DSL;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ConceptColumnSelectConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ConceptColumnSelectConverter.java
index 698cd1f472..1df4e48de4 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ConceptColumnSelectConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ConceptColumnSelectConverter.java
@@ -7,6 +7,8 @@
 
 import com.bakdata.conquery.models.datasets.concepts.Connector;
 import com.bakdata.conquery.models.datasets.concepts.select.concept.ConceptColumnSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.ExtractingSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConceptCteStep;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConceptSqlTables;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConnectorSqlTables;
@@ -14,8 +16,8 @@
 import com.bakdata.conquery.sql.conversion.model.CteStep;
 import com.bakdata.conquery.sql.conversion.model.NameGenerator;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import com.bakdata.conquery.sql.execution.ResultSetProcessor;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
@@ -102,7 +104,7 @@ private static QueryStep createUnionConnectorConnectorsStep(
 	) {
 		List<QueryStep> unionSteps = connectors.stream().map(connector -> createConnectorColumnSelectQuery(connector, alias, selectContext)).toList();
 		String unionedColumnsCteName = selectContext.getNameGenerator().cteStepName(CONCEPT_COLUMN_STEPS.UNIONED_COLUMNS, alias);
-		return QueryStep.createUnionStep(unionSteps, unionedColumnsCteName, Collections.emptyList(), false, selectContext.getFunctionProvider()); //TODO is false correct here?
+		return QueryStep.createUnionStep(unionSteps, unionedColumnsCteName, Collections.emptyList(), false); //TODO is false correct here?
 	}
 
 	private static QueryStep createConnectorColumnSelectQuery(
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ConceptSqlSelects.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ConceptSqlSelects.java
index df250611e7..65efbf98b1 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ConceptSqlSelects.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ConceptSqlSelects.java
@@ -3,6 +3,7 @@
 import java.util.List;
 import java.util.Optional;
 
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
 import lombok.Builder;
 import lombok.Singular;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ConnectorSqlSelects.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ConnectorSqlSelects.java
index 4d360d62ec..22fe539410 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ConnectorSqlSelects.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ConnectorSqlSelects.java
@@ -3,6 +3,7 @@
 import java.util.List;
 import java.util.Optional;
 
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
 import lombok.Builder;
 import lombok.Singular;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/DateUnionSelectConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/DateUnionSelectConverter.java
index a03f853483..31f0c94bdb 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/DateUnionSelectConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/DateUnionSelectConverter.java
@@ -1,6 +1,7 @@
 package com.bakdata.conquery.sql.conversion.model.select;
 
 import com.bakdata.conquery.models.datasets.concepts.select.connector.specific.DateUnionSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConnectorSqlTables;
 
 public class DateUnionSelectConverter implements SelectConverter<DateUnionSelect> {
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/DaterangeSelectUtil.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/DaterangeSelectUtil.java
index 005be1cd75..54ab2b4e9c 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/DaterangeSelectUtil.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/DaterangeSelectUtil.java
@@ -17,6 +17,9 @@
 import com.bakdata.conquery.models.datasets.concepts.DaterangeSelectOrFilter;
 import com.bakdata.conquery.models.datasets.concepts.select.Select;
 import com.bakdata.conquery.models.identifiable.LabeledNamespaceIdentifiable;
+import com.bakdata.conquery.sql.compiler.ir.select.ExtractingSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import com.bakdata.conquery.sql.conversion.Context;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConceptCteStep;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConnectorSqlTables;
@@ -24,12 +27,12 @@
 import com.bakdata.conquery.sql.conversion.cqelement.concept.IntervalPackingSelectsCte;
 import com.bakdata.conquery.sql.conversion.cqelement.intervalpacking.IntervalPackingContext;
 import com.bakdata.conquery.sql.conversion.cqelement.intervalpacking.IntervalPackingCteStep;
-import com.bakdata.conquery.sql.conversion.dialect.DialectBundle;
+import com.bakdata.conquery.sql.conversion.dialect.LegacyCompilerDialect;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.CteStep;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import com.bakdata.conquery.sql.conversion.model.SqlTables;
 import com.bakdata.conquery.sql.conversion.model.filter.SqlFilters;
 import com.bakdata.conquery.sql.conversion.model.filter.WhereClauses;
@@ -57,7 +60,7 @@ public static <S extends Select & DaterangeSelectOrFilter> ConnectorSqlSelects c
 											   .collect(Collectors.toList());
 
 		SqlTables daterangeSelectTables = createTables(alias, context.getTables(), context);
-		QueryStep lastIntervalPackingStep = applyIntervalPacking(daterange, daterangeSelectTables, context.getIds(), context.getTables(), context.getDialectBundle());
+		QueryStep lastIntervalPackingStep = applyIntervalPacking(daterange, daterangeSelectTables, context.getIds(), context.getTables(), context.getCompilerDialect());
 
 		ColumnDateRange qualified = daterange.qualify(daterangeSelectTables.getPredecessor(INTERVAL_PACKING_SELECTS));
 		FieldWrapper<?> aggregationField = aggregationFunction.apply(qualified, alias, functionProvider);
@@ -67,7 +70,7 @@ public static <S extends Select & DaterangeSelectOrFilter> ConnectorSqlSelects c
 				qualified,
 				aggregationField,
 				daterangeSelectTables,
-				context.getDialectBundle()
+				context.getCompilerDialect()
 		);
 
 		ConnectorSqlTables tables = context.getTables();
@@ -91,7 +94,7 @@ public static SqlFilters createForFilter(
 			FilterContext<?> context
 	) {
 		String alias = context.getNameGenerator().selectName((LabeledNamespaceIdentifiable<?>) filter);
-		SqlFunctionProvider functionProvider = context.getDialectBundle().getFunctionProvider();
+		SqlFunctionProvider functionProvider = context.getCompilerDialect().getFunctionProvider();
 
 		ColumnDateRange daterange = functionProvider.forArbitraryDateRange(filter).as(alias);
 		List<SqlSelect> rootSelects = daterange.toFields().stream()
@@ -99,7 +102,7 @@ public static SqlFilters createForFilter(
 											   .collect(Collectors.toList());
 
 		SqlTables daterangeSelectTables = createTables(alias, context.getTables(), context);
-		QueryStep lastIntervalPackingStep = applyIntervalPacking(daterange, daterangeSelectTables, context.getIds(), context.getTables(), context.getDialectBundle());
+		QueryStep lastIntervalPackingStep = applyIntervalPacking(daterange, daterangeSelectTables, context.getIds(), context.getTables(), context.getCompilerDialect());
 
 		ColumnDateRange qualified = daterange.qualify(daterangeSelectTables.getPredecessor(INTERVAL_PACKING_SELECTS));
 		FieldWrapper<?> aggregationField = aggregationFunction.apply(qualified, alias, functionProvider);
@@ -109,7 +112,7 @@ public static SqlFilters createForFilter(
 				qualified,
 				aggregationField,
 				daterangeSelectTables,
-				context.getDialectBundle()
+				context.getCompilerDialect()
 		);
 
 		ConnectorSqlSelects sqlSelects = ConnectorSqlSelects.builder()
@@ -143,8 +146,8 @@ private static Condition containsInfinityDate(ColumnDateRange validityDate, SqlF
 	private static SqlTables createTables(String alias, ConnectorSqlTables connectorTables, Context context) {
 		Map<CteStep, CteStep> predecessorMapping = new HashMap<>();
 		String preprocessingCteName = connectorTables.cteName(PREPROCESSING);
-		predecessorMapping.putAll(IntervalPackingCteStep.getMappings(context.getDialectBundle()));
-		if (context.getDialectBundle().supportsSingleColumnRanges()) {
+		predecessorMapping.putAll(IntervalPackingCteStep.getMappings(context.getCompilerDialect()));
+		if (context.getCompilerDialect().supportsSingleColumnRanges()) {
 			predecessorMapping.put(UNNEST_DATE, INTERVAL_COMPLETE);
 			predecessorMapping.put(INTERVAL_PACKING_SELECTS, UNNEST_DATE);
 		}
@@ -160,7 +163,7 @@ private static QueryStep applyIntervalPacking(
 			SqlTables dateUnionTables,
 			SqlIdColumns idColumns,
 			ConnectorSqlTables connectorSqlTables,
-			DialectBundle sqlDialect
+			LegacyCompilerDialect sqlDialect
 	) {
 		String preprocessingCteName = connectorSqlTables.cteName(PREPROCESSING);
 		IntervalPackingContext intervalPackingContext = IntervalPackingContext.builder()
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/DistinctSelectConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/DistinctSelectConverter.java
index c875bc4b32..faaea6c74a 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/DistinctSelectConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/DistinctSelectConverter.java
@@ -8,14 +8,16 @@
 
 import com.bakdata.conquery.models.datasets.concepts.select.connector.DistinctSelect;
 import com.bakdata.conquery.models.datasets.concepts.select.connector.specific.MappableSingleColumnSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.SingleColumnSqlSelect;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConceptCteStep;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConnectorSqlTables;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.CteStep;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import com.bakdata.conquery.sql.execution.ResultSetProcessor;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/EventDateUnionSelectConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/EventDateUnionSelectConverter.java
index 73cd607ae0..0163c6d94b 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/EventDateUnionSelectConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/EventDateUnionSelectConverter.java
@@ -1,11 +1,13 @@
 package com.bakdata.conquery.sql.conversion.model.select;
 
 import com.bakdata.conquery.models.datasets.concepts.select.concept.specific.EventDateUnionSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.ExtractingSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConceptCteStep;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConceptSqlTables;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConnectorSqlTables;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.google.common.base.Preconditions;
 
 public class EventDateUnionSelectConverter implements SelectConverter<EventDateUnionSelect> {
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/EventDurationSumSelectConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/EventDurationSumSelectConverter.java
index 7a9b21307b..34be5bac11 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/EventDurationSumSelectConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/EventDurationSumSelectConverter.java
@@ -5,11 +5,13 @@
 import java.time.temporal.ChronoUnit;
 
 import com.bakdata.conquery.models.datasets.concepts.select.concept.specific.EventDurationSumSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.ExtractingSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConceptCteStep;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConceptSqlTables;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConnectorSqlTables;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.google.common.base.Preconditions;
 import org.jooq.Condition;
 import org.jooq.Field;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ExistsSelectConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ExistsSelectConverter.java
index f79444f66e..f4c0fbecd7 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ExistsSelectConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ExistsSelectConverter.java
@@ -1,6 +1,7 @@
 package com.bakdata.conquery.sql.conversion.model.select;
 
 import com.bakdata.conquery.models.datasets.concepts.select.concept.specific.ExistsSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.ExistsSqlSelect;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConceptSqlTables;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConnectorSqlTables;
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ExtractingSqlSelect.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ExtractingSqlSelect.java
deleted file mode 100644
index 620c84efda..0000000000
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ExtractingSqlSelect.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package com.bakdata.conquery.sql.conversion.model.select;
-
-import java.util.List;
-
-import lombok.Value;
-import org.jooq.Field;
-import org.jooq.impl.DSL;
-
-/**
- * Select that does nothing but reference an existing column.
- * <p>
- * This can be used if another select requires a column in a later step.
- *
- * @param <T> type of column
- */
-@Value
-public class ExtractingSqlSelect<T> implements SingleColumnSqlSelect {
-
-	String table;
-	String column;
-	Class<T> columnClass;
-
-	@Override
-	public Field<T> select() {
-		return DSL.field(DSL.name(table, column), columnClass);
-	}
-
-	@Override
-	public Field<T> aliased() {
-		return DSL.field(DSL.name(column), columnClass);
-	}
-
-	@Override
-	public List<String> requiredColumns() {
-		return List.of(column);
-	}
-
-	@Override
-	public ExtractingSqlSelect<T> qualify(String qualifier) {
-		Field<T> aliased = aliased();
-		return new ExtractingSqlSelect<>(
-				qualifier,
-				aliased.getName(),
-				aliased.getType()
-		);
-	}
-
-}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/RandomValueSelectConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/RandomValueSelectConverter.java
index 100c74327d..0356879936 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/RandomValueSelectConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/RandomValueSelectConverter.java
@@ -1,6 +1,8 @@
 package com.bakdata.conquery.sql.conversion.model.select;
 
 import com.bakdata.conquery.models.datasets.concepts.select.connector.RandomValueSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.ExtractingSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConceptCteStep;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConnectorSqlTables;
 import org.jooq.Field;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/SelectContext.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/SelectContext.java
index 1239ef8d87..08e188f56d 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/SelectContext.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/SelectContext.java
@@ -6,10 +6,10 @@
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConceptSqlTables;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConnectorSqlTables;
-import com.bakdata.conquery.sql.conversion.dialect.DialectBundle;
+import com.bakdata.conquery.sql.conversion.dialect.LegacyCompilerDialect;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import com.bakdata.conquery.sql.conversion.model.SqlTables;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -25,8 +25,8 @@ public class SelectContext<T extends SqlTables> implements Context {
 	ConversionContext conversionContext;
 
 	@Override
-	public DialectBundle getDialectBundle() {
-		return getConversionContext().getDialectBundle();
+	public LegacyCompilerDialect getCompilerDialect() {
+		return getConversionContext().getCompilerDialect();
 	}
 
 	public static SelectContext<ConnectorSqlTables> create(
@@ -48,7 +48,7 @@ public static SelectContext<ConceptSqlTables> create(
 	}
 
 	public SqlFunctionProvider getFunctionProvider() {
-		return getDialectBundle().getFunctionProvider();
+		return getCompilerDialect().getFunctionProvider();
 	}
 
     public SqlIdColumns getIds() {
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/SingleColumnSqlSelect.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/SingleColumnSqlSelect.java
deleted file mode 100644
index 6004b196ee..0000000000
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/SingleColumnSqlSelect.java
+++ /dev/null
@@ -1,29 +0,0 @@
-package com.bakdata.conquery.sql.conversion.model.select;
-
-import java.util.List;
-
-import org.jooq.Field;
-
-public interface SingleColumnSqlSelect extends SqlSelect {
-
-	/**
-	 * @return The whole (aliased) SQL expression of this {@link SqlSelect}.
-	 * For example, {@code DSL.firstValue(DSL.field(DSL.name("foo", "bar"))).as("foobar")}.
-	 */
-	Field<?> select();
-
-	/**
-	 * @return Aliased column name that can be used to reference the created select.
-	 * For example, {@code DSL.field("foobar")}.
-	 */
-	Field<?> aliased();
-
-	@Override
-	SingleColumnSqlSelect qualify(String qualifier);
-
-	@Override
-	default List<Field<?>> toFields() {
-		return List.of(select());
-	}
-
-}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/SqlSelect.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/SqlSelect.java
deleted file mode 100644
index 5ca54b46c4..0000000000
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/SqlSelect.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package com.bakdata.conquery.sql.conversion.model.select;
-
-import com.bakdata.conquery.models.datasets.concepts.select.concept.specific.ExistsSelect;
-import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.Qualifiable;
-import org.jooq.Field;
-
-import java.util.List;
-
-public interface SqlSelect extends Qualifiable<SqlSelect> {
-
-	List<Field<?>> toFields();
-
-	/**
-	 * All column names this {@link SqlSelect} requires.
-	 */
-	List<String> requiredColumns();
-
-	/**
-	 * @return Determines if this SqlSelect is only part of the final concept conversion CTE and has no predeceasing selects.
-	 */
-	default boolean isUniversal() {
-		return false;
-	}
-
-	/**
-	 * Special selects like {@link ExistsSelect} require an extra aggregation when joining them with other connectors.
-	 */
-	default SqlSelect connectorAggregate() {
-		return this;
-	}
-
-	/**
-	 * Special selects like {@link ExistsSelect} require to be converted into a specific format before executing the
-	 * final query.
-	 */
-	default SqlSelect toFinalRepresentation() {
-		return this;
-	}
-
-	/**
-	 * Aggregate this select to one value per ID group in the final concept query.
-	 */
-	default List<Field<?>> aggregateForFinalQuery(SqlFunctionProvider functionProvider) {
-		return toFinalRepresentation().toFields().stream()
-				.<Field<?>>map(field -> functionProvider.anyValue(field).as(field.getName()))
-				.toList();
-	}
-
-}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ValueSelectUtil.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ValueSelectUtil.java
index e37d70b2a8..8afaefd21a 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ValueSelectUtil.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ValueSelectUtil.java
@@ -9,14 +9,17 @@
 import com.bakdata.conquery.models.common.Range;
 import com.bakdata.conquery.models.datasets.Column;
 import com.bakdata.conquery.models.datasets.concepts.select.connector.specific.MappableSingleColumnSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.SingleColumnSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConceptCteStep;
 import com.bakdata.conquery.sql.conversion.cqelement.concept.ConnectorSqlTables;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.CteStep;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import org.jetbrains.annotations.NotNull;
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/AbsoluteFormQueryConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/AbsoluteFormQueryConverter.java
index e63356c199..e912b300ef 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/AbsoluteFormQueryConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/AbsoluteFormQueryConverter.java
@@ -7,15 +7,15 @@
 import com.bakdata.conquery.models.common.daterange.CDateRange;
 import com.bakdata.conquery.models.forms.managed.AbsoluteFormQuery;
 import com.bakdata.conquery.sql.conversion.NodeConverter;
-import com.bakdata.conquery.sql.conversion.SharedAliases;
+import com.bakdata.conquery.sql.compiler.ir.SharedAliases;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
 import com.bakdata.conquery.sql.conversion.forms.FormCteStep;
 import com.bakdata.conquery.sql.conversion.forms.FormType;
 import com.bakdata.conquery.sql.conversion.forms.StratificationTableFactory;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
-import com.bakdata.conquery.sql.conversion.model.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
 import com.google.common.base.Preconditions;
 import lombok.RequiredArgsConstructor;
 
@@ -55,7 +55,7 @@ private static QueryStep convertPrerequisite(AbsoluteFormQuery absoluteForm, Con
 		Preconditions.checkArgument(withConvertedPrerequisite.getQuerySteps().size() == 1, "Base query conversion should produce exactly 1 QueryStep");
 		QueryStep convertedPrerequisite = withConvertedPrerequisite.getLastConvertedStep();
 
-		ColumnDateRange bounds = context.getDialectBundle()
+		ColumnDateRange bounds = context.getCompilerDialect()
 										.getFunctionProvider()
 										.forCDateRange(CDateRange.of(absoluteForm.getDateRange())).as(SharedAliases.STRATIFICATION_BOUNDS.getAlias());
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/ConceptQueryConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/ConceptQueryConverter.java
index 343b70a2ae..0cf7ffca15 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/ConceptQueryConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/ConceptQueryConverter.java
@@ -1,14 +1,17 @@
 package com.bakdata.conquery.sql.conversion.query;
 
+import com.bakdata.conquery.sql.compiler.ir.Selects;
 import com.bakdata.conquery.apiv1.query.ConceptQuery;
 import com.bakdata.conquery.apiv1.query.concept.specific.CQNegation;
 import com.bakdata.conquery.models.query.DateAggregationMode;
+import com.bakdata.conquery.sql.compiler.dialect.CompilerDialect;
 import com.bakdata.conquery.sql.conversion.NodeConverter;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
+import com.bakdata.conquery.sql.conversion.dialect.LegacyCompilerDialect;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
 import com.bakdata.conquery.sql.conversion.model.*;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import lombok.RequiredArgsConstructor;
 import org.jooq.*;
 import org.jooq.Record;
@@ -56,7 +59,6 @@ public Class<ConceptQuery> getConversionClass() {
 	@Override
 	public ConversionContext convert(ConceptQuery conceptQuery, ConversionContext context) {
 
-		SqlFunctionProvider functionProvider = context.getDialectBundle().getFunctionProvider();
 		ConversionContext contextAfterConversion = context.getNodeConversions().convert(conceptQuery.getRoot(), context);
 
 		QueryStep preFinalStep = contextAfterConversion.getLastConvertedStep();
@@ -70,17 +72,18 @@ public ConversionContext convert(ConceptQuery conceptQuery, ConversionContext co
 
 		QueryStep finalStep = QueryStep.builder()
 				.cteName(null)  // the final QueryStep won't be converted to a CTE
-				.selects(getFinalSelects(conceptQuery, preFinalSelects, functionProvider))
+				.selects(getFinalSelects(conceptQuery, preFinalSelects, context.getCompilerDialect()))
 				.fromTable(getFinalTable(preFinalStep, contextAfterConversion))
 				.groupBy(getFinalGroupBySelects(preFinalSelects))
 				.predecessors(predecessors)
 				.build();
 
-		Select<Record> finalQuery = this.queryStepTransformer.toSelectQuery(finalStep, functionProvider);
+		Select<Record> finalQuery = this.queryStepTransformer.toSelectQuery(finalStep, context.getCompilerDialect());
 		return contextAfterConversion.withFinalQuery(new SqlQuery(finalQuery, conceptQuery.getResultInfos()));
 	}
 
-	private Selects getFinalSelects(ConceptQuery conceptQuery, Selects preFinalSelects, SqlFunctionProvider functionProvider) {
+	private Selects getFinalSelects(ConceptQuery conceptQuery, Selects preFinalSelects, LegacyCompilerDialect dialect) {
+		SqlFunctionProvider functionProvider = dialect.getFunctionProvider();
 		Selects finalSelects = preFinalSelects;
 		if (conceptQuery.getDateAggregationMode() == DateAggregationMode.NONE) {
 			finalSelects = preFinalSelects.blockValidityDate();
@@ -96,13 +99,13 @@ private Selects getFinalSelects(ConceptQuery conceptQuery, Selects preFinalSelec
 				.ids(finalSelects.getIds())
 				.validityDate(finalSelects.getValidityDate())
 				.stratificationDate(finalSelects.getStratificationDate())
-				.sqlSelects(getFinalAggregatedSelects(finalSelects, functionProvider))
+				.sqlSelects(getFinalAggregatedSelects(finalSelects, dialect))
 				.build();
 	}
 
-	private List<? extends FieldWrapper<?>> getFinalAggregatedSelects(Selects finalSelects, SqlFunctionProvider functionProvider) {
+	private List<? extends FieldWrapper<?>> getFinalAggregatedSelects(Selects finalSelects, CompilerDialect dialect) {
 		return finalSelects.getSqlSelects().stream()
-				.flatMap(sqlSelect -> sqlSelect.aggregateForFinalQuery(functionProvider).stream())
+				.flatMap(sqlSelect -> sqlSelect.aggregateForFinalQuery(dialect).stream())
 				.map(this::toFieldWrapper)
 				.toList();
 	}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/EntityDateQueryConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/EntityDateQueryConverter.java
index 71bb59a32c..16627292b8 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/EntityDateQueryConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/EntityDateQueryConverter.java
@@ -5,15 +5,15 @@
 
 import com.bakdata.conquery.models.forms.managed.EntityDateQuery;
 import com.bakdata.conquery.sql.conversion.NodeConverter;
-import com.bakdata.conquery.sql.conversion.SharedAliases;
+import com.bakdata.conquery.sql.compiler.ir.SharedAliases;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
 import com.bakdata.conquery.sql.conversion.forms.FormCteStep;
 import com.bakdata.conquery.sql.conversion.forms.FormType;
 import com.bakdata.conquery.sql.conversion.forms.StratificationTableFactory;
-import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
 import com.bakdata.conquery.sql.conversion.model.QueryStep;
-import com.bakdata.conquery.sql.conversion.model.Selects;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
 import com.google.common.base.Preconditions;
 import lombok.RequiredArgsConstructor;
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/FormConversionHelper.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/FormConversionHelper.java
index 75b32f027b..3ac74ff0bf 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/FormConversionHelper.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/FormConversionHelper.java
@@ -1,18 +1,21 @@
 package com.bakdata.conquery.sql.conversion.query;
 
+import com.bakdata.conquery.sql.compiler.ir.Selects;
 import com.bakdata.conquery.apiv1.forms.FeatureGroup;
 import com.bakdata.conquery.apiv1.query.ArrayConceptQuery;
 import com.bakdata.conquery.apiv1.query.ConceptQuery;
 import com.bakdata.conquery.apiv1.query.Query;
+import com.bakdata.conquery.models.forms.util.Resolution;
 import com.bakdata.conquery.models.query.queryplan.DateAggregationAction;
 import com.bakdata.conquery.models.query.resultinfo.ResultInfo;
-import com.bakdata.conquery.sql.conversion.SharedAliases;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.ir.SharedAliases;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
-import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
 import com.bakdata.conquery.sql.conversion.forms.FormCteStep;
 import com.bakdata.conquery.sql.conversion.forms.FormType;
 import com.bakdata.conquery.sql.conversion.model.*;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
 import com.google.common.base.Preconditions;
 import lombok.RequiredArgsConstructor;
 import org.jooq.*;
@@ -42,7 +45,7 @@ private static Selects getFinalSelects(
 		Selects preFinalSelects = convertedFeatures.getQualifiedSelects();
 		Selects stratificationSelects = stratificationTable.getQualifiedSelects();
 
-		SqlIdColumns ids = stratificationSelects.getIds().forFinalSelect();
+		SqlIdColumns ids = stratificationSelects.getIds().forFinalSelect(Resolution.COMPLETE.name());
 
 		Selects.SelectsBuilder selects = Selects.builder()
 				.ids(ids)
@@ -146,8 +149,6 @@ private ConversionContext createFinalSelect(
 
 		List<QueryStep> queriesToJoin = List.of(stratificationTable, convertedFeatures);
 		TableLike<Record> joinedTable = QueryStepJoiner.constructJoinedTable(queriesToJoin, ConqueryJoinType.LEFT_JOIN, context);
-		SqlFunctionProvider functionProvider = context.getFunctionProvider();
-
 		QueryStep finalStep = QueryStep.builder()
 				.cteName(null)  // the final QueryStep won't be converted to a CTE
 				.selects(getFinalSelects(formType, stratificationTable, convertedFeatures))
@@ -155,7 +156,7 @@ private ConversionContext createFinalSelect(
 				.predecessors(queriesToJoin)
 				.build();
 
-		Select<Record> selectQuery = queryStepTransformer.toSelectQuery(finalStep, functionProvider);
+		Select<Record> selectQuery = queryStepTransformer.toSelectQuery(finalStep, context.getCompilerDialect());
 		return context.withFinalQuery(new SqlQuery(selectQuery, resultInfos));
 	}
 
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/TableExportQueryConverter.java b/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/TableExportQueryConverter.java
index 5fe2b44e41..9dbe26987d 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/TableExportQueryConverter.java
+++ b/backend/src/main/java/com/bakdata/conquery/sql/conversion/query/TableExportQueryConverter.java
@@ -1,5 +1,6 @@
 package com.bakdata.conquery.sql.conversion.query;
 
+import com.bakdata.conquery.sql.compiler.ir.Selects;
 import com.bakdata.conquery.apiv1.query.Query;
 import com.bakdata.conquery.apiv1.query.TableExportQuery;
 import com.bakdata.conquery.apiv1.query.concept.filter.CQTable;
@@ -7,13 +8,15 @@
 import com.bakdata.conquery.models.common.daterange.CDateRange;
 import com.bakdata.conquery.models.datasets.Column;
 import com.bakdata.conquery.models.identifiable.ids.specific.ColumnId;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
 import com.bakdata.conquery.sql.conversion.NodeConverter;
-import com.bakdata.conquery.sql.conversion.SharedAliases;
+import com.bakdata.conquery.sql.compiler.ir.SharedAliases;
 import com.bakdata.conquery.sql.conversion.cqelement.ConversionContext;
 import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
 import com.bakdata.conquery.sql.conversion.forms.FormCteStep;
 import com.bakdata.conquery.sql.conversion.model.*;
-import com.bakdata.conquery.sql.conversion.model.select.FieldWrapper;
 import com.bakdata.conquery.util.TablePrimaryColumnUtil;
 import com.google.common.base.Preconditions;
 import lombok.RequiredArgsConstructor;
@@ -206,9 +209,9 @@ public ConversionContext convert(TableExportQuery tableExportQuery, ConversionCo
 				convertedTables,
 				null, // no CTE name required as this step will be the final select
 				List.of(convertedPrerequisite),
-				context.isNegation(), context.getFunctionProvider()
+				context.isNegation()
 		);
-		final Select<Record> selectQuery = queryStepTransformer.toSelectQuery(unionedTables, context.getFunctionProvider());
+		final Select<Record> selectQuery = queryStepTransformer.toSelectQuery(unionedTables, context.getCompilerDialect());
 
 		return context.withFinalQuery(new SqlQuery(selectQuery, tableExportQuery.getResultInfos()));
 	}
diff --git a/dataset-model/README.md b/dataset-model/README.md
new file mode 100644
index 0000000000..d10f263d63
--- /dev/null
+++ b/dataset-model/README.md
@@ -0,0 +1,7 @@
+# Dataset model
+
+This module contains the dependency-free dataset vocabulary shared by query producers, plugins, and execution engines.
+It must not depend on a backend framework, persistence technology, or SQL implementation.
+
+Keep types here only when they have the same meaning for every consumer. Backend storage records and SQL compilation
+types remain in their respective modules and reference this shared vocabulary.
diff --git a/dataset-model/pom.xml b/dataset-model/pom.xml
new file mode 100644
index 0000000000..e567eca481
--- /dev/null
+++ b/dataset-model/pom.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.bakdata.conquery</groupId>
+        <artifactId>parent</artifactId>
+        <version>${revision}</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+
+    <artifactId>dataset-model</artifactId>
+    <name>Conquery Dataset Model</name>
+</project>
diff --git a/dataset-model/src/main/java/com/bakdata/conquery/models/datasets/ColumnDescriptor.java b/dataset-model/src/main/java/com/bakdata/conquery/models/datasets/ColumnDescriptor.java
new file mode 100644
index 0000000000..3f61572d6c
--- /dev/null
+++ b/dataset-model/src/main/java/com/bakdata/conquery/models/datasets/ColumnDescriptor.java
@@ -0,0 +1,5 @@
+package com.bakdata.conquery.models.datasets;
+
+/** Framework-neutral description of a validated dataset column. */
+public record ColumnDescriptor(String name, ColumnType type) {
+}
diff --git a/dataset-model/src/main/java/com/bakdata/conquery/models/datasets/ColumnType.java b/dataset-model/src/main/java/com/bakdata/conquery/models/datasets/ColumnType.java
new file mode 100644
index 0000000000..d522d392d8
--- /dev/null
+++ b/dataset-model/src/main/java/com/bakdata/conquery/models/datasets/ColumnType.java
@@ -0,0 +1,13 @@
+package com.bakdata.conquery.models.datasets;
+
+/** Logical type of a dataset column. */
+public enum ColumnType {
+	STRING,
+	INTEGER,
+	BOOLEAN,
+	REAL,
+	DECIMAL,
+	MONEY,
+	DATE,
+	DATE_RANGE
+}
diff --git a/dataset-model/src/main/java/com/bakdata/conquery/models/datasets/package-info.java b/dataset-model/src/main/java/com/bakdata/conquery/models/datasets/package-info.java
new file mode 100644
index 0000000000..4f9a0019d6
--- /dev/null
+++ b/dataset-model/src/main/java/com/bakdata/conquery/models/datasets/package-info.java
@@ -0,0 +1,2 @@
+/** Framework-neutral dataset types shared by query producers, plugins, and execution engines. */
+package com.bakdata.conquery.models.datasets;
diff --git a/flake.lock b/flake.lock
new file mode 100644
index 0000000000..db686c56b7
--- /dev/null
+++ b/flake.lock
@@ -0,0 +1,61 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1767313136,
+        "narHash": "sha256-16KkgfdYqjaeRGBaYsNrhPRRENs0qzkQVUooNHtoy2w=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "ac62194c3917d5f474c1a844b6fd6da2db95077d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-25.05",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
diff --git a/flake.nix b/flake.nix
new file mode 100644
index 0000000000..cd5f8202f3
--- /dev/null
+++ b/flake.nix
@@ -0,0 +1,34 @@
+{
+  description = "Local dev shell for Conquery";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.05";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { self, nixpkgs, flake-utils }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = import nixpkgs { inherit system; };
+      in
+      {
+        devShells.default = pkgs.mkShell {
+          packages = with pkgs; [
+            jdk21
+            maven
+            nodejs_20
+            git
+            curl
+            jq
+            ripgrep
+            python312
+          ];
+
+          shellHook = ''
+            export JAVA_HOME=${pkgs.jdk21}
+            export PATH="$JAVA_HOME/bin:$PATH"
+            echo "Conquery dev shell ready: java=$(java -version 2>&1 | head -n 1), node=$(node -v)"
+          '';
+        };
+      });
+}
diff --git a/mvnw b/mvnw
new file mode 100755
index 0000000000..df1a80ac19
--- /dev/null
+++ b/mvnw
@@ -0,0 +1,338 @@
+#!/bin/sh
+# ----------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Apache Maven Wrapper startup batch script, version @@project.version@@
+#
+# Required ENV vars:
+# ------------------
+#   JAVA_HOME - location of a JDK home dir
+#
+# Optional ENV vars
+# -----------------
+#   MAVEN_OPTS - parameters passed to the Java VM when running Maven
+#     e.g. to debug Maven itself, use
+#       set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+#   MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+# ----------------------------------------------------------------------------
+
+if [ -z "$MAVEN_SKIP_RC" ]; then
+
+  if [ -f /usr/local/etc/mavenrc ]; then
+    . /usr/local/etc/mavenrc
+  fi
+
+  if [ -f /etc/mavenrc ]; then
+    . /etc/mavenrc
+  fi
+
+  if [ -f "$HOME/.mavenrc" ]; then
+    . "$HOME/.mavenrc"
+  fi
+
+fi
+
+# OS specific support.  $var _must_ be set to either true or false.
+cygwin=false
+darwin=false
+mingw=false
+case "$(uname)" in
+CYGWIN*) cygwin=true ;;
+MINGW*) mingw=true ;;
+Darwin*)
+  darwin=true
+  # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
+  # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
+  if [ -z "$JAVA_HOME" ]; then
+    if [ -x "/usr/libexec/java_home" ]; then
+      JAVA_HOME="$(/usr/libexec/java_home)"
+      export JAVA_HOME
+    else
+      JAVA_HOME="/Library/Java/Home"
+      export JAVA_HOME
+    fi
+  fi
+  ;;
+esac
+
+if [ -z "$JAVA_HOME" ]; then
+  if [ -r /etc/gentoo-release ]; then
+    JAVA_HOME=$(java-config --jre-home)
+  fi
+fi
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched
+if $cygwin; then
+  [ -n "$JAVA_HOME" ] \
+    && JAVA_HOME=$(cygpath --unix "$JAVA_HOME")
+  [ -n "$CLASSPATH" ] \
+    && CLASSPATH=$(cygpath --path --unix "$CLASSPATH")
+fi
+
+# For Mingw, ensure paths are in UNIX format before anything is touched
+if $mingw; then
+  [ -n "$JAVA_HOME" ] && [ -d "$JAVA_HOME" ] \
+    && JAVA_HOME="$(
+      cd "$JAVA_HOME" || (
+        echo "cannot cd into $JAVA_HOME." >&2
+        exit 1
+      )
+      pwd
+    )"
+fi
+
+if [ -z "$JAVA_HOME" ]; then
+  javaExecutable="$(which javac)"
+  if [ -n "$javaExecutable" ] && ! [ "$(expr "$javaExecutable" : '\([^ ]*\)')" = "no" ]; then
+    # readlink(1) is not available as standard on Solaris 10.
+    readLink=$(which readlink)
+    if [ ! "$(expr "$readLink" : '\([^ ]*\)')" = "no" ]; then
+      if $darwin; then
+        javaHome="$(dirname "$javaExecutable")"
+        javaExecutable="$(cd "$javaHome" && pwd -P)/javac"
+      else
+        javaExecutable="$(readlink -f "$javaExecutable")"
+      fi
+      javaHome="$(dirname "$javaExecutable")"
+      javaHome=$(expr "$javaHome" : '\(.*\)/bin')
+      JAVA_HOME="$javaHome"
+      export JAVA_HOME
+    fi
+  fi
+fi
+
+if [ -z "$JAVACMD" ]; then
+  if [ -n "$JAVA_HOME" ]; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ]; then
+      # IBM's JDK on AIX uses strange locations for the executables
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+    fi
+  else
+    JAVACMD="$(
+      \unset -f command 2>/dev/null
+      \command -v java
+    )"
+  fi
+fi
+
+if [ ! -x "$JAVACMD" ]; then
+  echo "Error: JAVA_HOME is not defined correctly." >&2
+  echo "  We cannot execute $JAVACMD" >&2
+  exit 1
+fi
+
+if [ -z "$JAVA_HOME" ]; then
+  echo "Warning: JAVA_HOME environment variable is not set." >&2
+fi
+
+# traverses directory structure from process work directory to filesystem root
+# first directory with .mvn subdirectory is considered project base directory
+find_maven_basedir() {
+  if [ -z "$1" ]; then
+    echo "Path not specified to find_maven_basedir" >&2
+    return 1
+  fi
+
+  basedir="$1"
+  wdir="$1"
+  while [ "$wdir" != '/' ]; do
+    if [ -d "$wdir"/.mvn ]; then
+      basedir=$wdir
+      break
+    fi
+    # workaround for JBEAP-8937 (on Solaris 10/Sparc)
+    if [ -d "${wdir}" ]; then
+      wdir=$(
+        cd "$wdir/.." || exit 1
+        pwd
+      )
+    fi
+    # end of workaround
+  done
+  printf '%s' "$(
+    cd "$basedir" || exit 1
+    pwd
+  )"
+}
+
+# concatenates all lines of a file
+concat_lines() {
+  if [ -f "$1" ]; then
+    # Remove \r in case we run on Windows within Git Bash
+    # and check out the repository with auto CRLF management
+    # enabled. Otherwise, we may read lines that are delimited with
+    # \r\n and produce $'-Xarg\r' rather than -Xarg due to word
+    # splitting rules.
+    tr -s '\r\n' ' ' <"$1"
+  fi
+}
+
+log() {
+  if [ "$MVNW_VERBOSE" = true ]; then
+    printf '%s\n' "$1"
+  fi
+}
+
+BASE_DIR=$(find_maven_basedir "$(dirname "$0")")
+if [ -z "$BASE_DIR" ]; then
+  exit 1
+fi
+
+MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}
+export MAVEN_PROJECTBASEDIR
+log "$MAVEN_PROJECTBASEDIR"
+
+trim() {
+  # MWRAPPER-139:
+  #   Trims trailing and leading whitespace, carriage returns, tabs, and linefeeds.
+  #   Needed for removing poorly interpreted newline sequences when running in more
+  #   exotic environments such as mingw bash on Windows.
+  printf "%s" "${1}" | tr -d '[:space:]'
+}
+
+##########################################################################################
+# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+# This allows using the maven wrapper in projects that prohibit checking in binary data.
+##########################################################################################
+wrapperJarPath="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar"
+if [ -r "$wrapperJarPath" ]; then
+  log "Found $wrapperJarPath"
+else
+  log "Couldn't find $wrapperJarPath, downloading it ..."
+
+  if [ -n "$MVNW_REPOURL" ]; then
+    wrapperUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/@@project.version@@/maven-wrapper-@@project.version@@.jar"
+  else
+    wrapperUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/@@project.version@@/maven-wrapper-@@project.version@@.jar"
+  fi
+  while IFS="=" read -r key value; do
+    case "$key" in wrapperUrl)
+      wrapperUrl=$(trim "${value-}")
+      break
+      ;;
+    esac
+  done <"$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
+  log "Downloading from: $wrapperUrl"
+
+  if $cygwin; then
+    wrapperJarPath=$(cygpath --path --windows "$wrapperJarPath")
+  fi
+
+  if command -v wget >/dev/null; then
+    log "Found wget ... using wget"
+    [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--quiet"
+    if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+      wget ${QUIET:+"$QUIET"} "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+    else
+      wget ${QUIET:+"$QUIET"} --http-user="$MVNW_USERNAME" --http-password="$MVNW_PASSWORD" "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+    fi
+  elif command -v curl >/dev/null; then
+    log "Found curl ... using curl"
+    [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--silent"
+    if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+      curl ${QUIET:+"$QUIET"} -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath"
+    else
+      curl ${QUIET:+"$QUIET"} --user "$MVNW_USERNAME:$MVNW_PASSWORD" -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath"
+    fi
+  else
+    log "Falling back to using Java to download"
+    javaSource="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.java"
+    javaClass="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.class"
+    # For Cygwin, switch paths to Windows format before running javac
+    if $cygwin; then
+      javaSource=$(cygpath --path --windows "$javaSource")
+      javaClass=$(cygpath --path --windows "$javaClass")
+    fi
+    if [ -e "$javaSource" ]; then
+      if [ ! -e "$javaClass" ]; then
+        log " - Compiling MavenWrapperDownloader.java ..."
+        ("$JAVA_HOME/bin/javac" "$javaSource")
+      fi
+      if [ -e "$javaClass" ]; then
+        log " - Running MavenWrapperDownloader.java ..."
+        ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$wrapperUrl" "$wrapperJarPath") || rm -f "$wrapperJarPath"
+      fi
+    fi
+  fi
+fi
+##########################################################################################
+# End of extension
+##########################################################################################
+
+# If specified, validate the SHA-256 sum of the Maven wrapper jar file
+wrapperSha256Sum=""
+while IFS="=" read -r key value; do
+  case "$key" in wrapperSha256Sum)
+    wrapperSha256Sum=$(trim "${value-}")
+    break
+    ;;
+  esac
+done <"$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
+if [ -n "$wrapperSha256Sum" ]; then
+  wrapperSha256Result=false
+  if command -v sha256sum >/dev/null; then
+    if echo "$wrapperSha256Sum  $wrapperJarPath" | sha256sum -c --strict - >/dev/null 2>&1; then
+      wrapperSha256Result=true
+    fi
+  elif command -v shasum >/dev/null; then
+    if echo "$wrapperSha256Sum  $wrapperJarPath" | shasum -a 256 -c >/dev/null 2>&1; then
+      wrapperSha256Result=true
+    fi
+  else
+    echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2
+    echo "Please install either command, or disable validation by removing 'wrapperSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  fi
+  if [ $wrapperSha256Result = false ]; then
+    echo "Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised." >&2
+    echo "Investigate or delete $wrapperJarPath to attempt a clean download." >&2
+    echo "If you updated your Maven version, you need to update the specified wrapperSha256Sum property." >&2
+    exit 1
+  fi
+fi
+
+MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin; then
+  [ -n "$JAVA_HOME" ] \
+    && JAVA_HOME=$(cygpath --path --windows "$JAVA_HOME")
+  [ -n "$CLASSPATH" ] \
+    && CLASSPATH=$(cygpath --path --windows "$CLASSPATH")
+  [ -n "$MAVEN_PROJECTBASEDIR" ] \
+    && MAVEN_PROJECTBASEDIR=$(cygpath --path --windows "$MAVEN_PROJECTBASEDIR")
+fi
+
+# Provide a "standardized" way to retrieve the CLI args that will
+# work with both Windows and non-Windows executions.
+MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $*"
+export MAVEN_CMD_LINE_ARGS
+
+WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+# shellcheck disable=SC2086 # safe args
+exec "$JAVACMD" \
+  $MAVEN_OPTS \
+  $MAVEN_DEBUG_OPTS \
+  -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
+  "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
+  ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"
diff --git a/mvnw.cmd b/mvnw.cmd
new file mode 100644
index 0000000000..97fff17750
--- /dev/null
+++ b/mvnw.cmd
@@ -0,0 +1,206 @@
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements.  See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership.  The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License.  You may obtain a copy of the License at
+@REM
+@REM    http://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied.  See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Apache Maven Wrapper startup batch script, version @@project.version@@
+@REM
+@REM Required ENV vars:
+@REM JAVA_HOME - location of a JDK home dir
+@REM
+@REM Optional ENV vars
+@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
+@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending
+@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
+@REM     e.g. to debug Maven itself, use
+@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+@REM ----------------------------------------------------------------------------
+
+@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
+@echo off
+@REM set title of command window
+title %0
+@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on'
+@if "%MAVEN_BATCH_ECHO%" == "on"  echo %MAVEN_BATCH_ECHO%
+
+@REM set %HOME% to equivalent of $HOME
+if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
+
+@REM Execute a user defined script before this one
+if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
+@REM check for pre script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %*
+if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %*
+:skipRcPre
+
+@setlocal
+
+set ERROR_CODE=0
+
+@REM To isolate internal variables from possible post scripts, we use another setlocal
+@setlocal
+
+@REM ==== START VALIDATION ====
+if not "%JAVA_HOME%" == "" goto OkJHome
+
+echo. >&2
+echo Error: JAVA_HOME not found in your environment. >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo. >&2
+goto error
+
+:OkJHome
+if exist "%JAVA_HOME%\bin\java.exe" goto init
+
+echo. >&2
+echo Error: JAVA_HOME is set to an invalid directory. >&2
+echo JAVA_HOME = "%JAVA_HOME%" >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo. >&2
+goto error
+
+@REM ==== END VALIDATION ====
+
+:init
+
+@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
+@REM Fallback to current working directory if not found.
+
+set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
+IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
+
+set EXEC_DIR=%CD%
+set WDIR=%EXEC_DIR%
+:findBaseDir
+IF EXIST "%WDIR%"\.mvn goto baseDirFound
+cd ..
+IF "%WDIR%"=="%CD%" goto baseDirNotFound
+set WDIR=%CD%
+goto findBaseDir
+
+:baseDirFound
+set MAVEN_PROJECTBASEDIR=%WDIR%
+cd "%EXEC_DIR%"
+goto endDetectBaseDir
+
+:baseDirNotFound
+set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
+cd "%EXEC_DIR%"
+
+:endDetectBaseDir
+
+IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
+
+@setlocal EnableExtensions EnableDelayedExpansion
+for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
+@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
+
+:endReadAdditionalConfig
+
+SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
+set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
+set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+set WRAPPER_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/@@project.version@@/maven-wrapper-@@project.version@@.jar"
+
+FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
+    IF "%%A"=="wrapperUrl" SET WRAPPER_URL=%%B
+)
+
+@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+@REM This allows using the maven wrapper in projects that prohibit checking in binary data.
+if exist %WRAPPER_JAR% (
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Found %WRAPPER_JAR%
+    )
+) else (
+    if not "%MVNW_REPOURL%" == "" (
+        SET WRAPPER_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/@@project.version@@/maven-wrapper-@@project.version@@.jar"
+    )
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Couldn't find %WRAPPER_JAR%, downloading it ...
+        echo Downloading from: %WRAPPER_URL%
+    )
+
+    powershell -Command "&{"^
+        "$webclient = new-object System.Net.WebClient;"^
+        "if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^
+        "$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^
+        "}"^
+        "[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%WRAPPER_URL%', '%WRAPPER_JAR%')"^
+        "}"
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Finished downloading %WRAPPER_JAR%
+    )
+)
+@REM End of extension
+
+@REM If specified, validate the SHA-256 sum of the Maven wrapper jar file
+SET WRAPPER_SHA_256_SUM=""
+FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
+    IF "%%A"=="wrapperSha256Sum" SET WRAPPER_SHA_256_SUM=%%B
+)
+IF NOT %WRAPPER_SHA_256_SUM%=="" (
+    powershell -Command "&{"^
+       "Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash;"^
+       "$hash = (Get-FileHash \"%WRAPPER_JAR%\" -Algorithm SHA256).Hash.ToLower();"^
+       "If('%WRAPPER_SHA_256_SUM%' -ne $hash){"^
+       "  Write-Error 'Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised.';"^
+       "  Write-Error 'Investigate or delete %WRAPPER_JAR% to attempt a clean download.';"^
+       "  Write-Error 'If you updated your Maven version, you need to update the specified wrapperSha256Sum property.';"^
+       "  exit 1;"^
+       "}"^
+       "}"
+    if ERRORLEVEL 1 goto error
+)
+
+@REM Provide a "standardized" way to retrieve the CLI args that will
+@REM work with both Windows and non-Windows executions.
+set MAVEN_CMD_LINE_ARGS=%*
+
+%MAVEN_JAVA_EXE% ^
+  %JVM_CONFIG_MAVEN_PROPS% ^
+  %MAVEN_OPTS% ^
+  %MAVEN_DEBUG_OPTS% ^
+  -classpath %WRAPPER_JAR% ^
+  "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^
+  %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
+if ERRORLEVEL 1 goto error
+goto end
+
+:error
+set ERROR_CODE=1
+
+:end
+@endlocal & set ERROR_CODE=%ERROR_CODE%
+
+if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost
+@REM check for post script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat"
+if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd"
+:skipRcPost
+
+@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
+if "%MAVEN_BATCH_PAUSE%"=="on" pause
+
+if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE%
+
+cmd /C exit /B %ERROR_CODE%
diff --git a/pom.xml b/pom.xml
index 860dda8e2f..4bbac60482 100644
--- a/pom.xml
+++ b/pom.xml
@@ -18,6 +18,7 @@
 
     <properties>
         <java.required>21</java.required>
+        <jooq.version>3.20.2</jooq.version>
         <lombok.version>1.18.36</lombok.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <maven.compiler.source>${java.required}</maven.compiler.source>
@@ -29,7 +30,12 @@
     </properties>
 
     <modules>
+        <module>dataset-model</module>
+        <module>sql-connector</module>
         <module>backend</module>
+        <module>backend-quarkus-plugin-api</module>
+        <module>backend-quarkus</module>
+        <module>backend-quarkus-plugin-test</module>
         <module>executable</module>
         <module>autodoc</module>
     </modules>
@@ -129,4 +135,4 @@
             </plugin>
         </plugins>
     </build>
-</project>
\ No newline at end of file
+</project>
diff --git a/scripts/normalize_concept_connector_columns.py b/scripts/normalize_concept_connector_columns.py
new file mode 100755
index 0000000000..079d735ba7
--- /dev/null
+++ b/scripts/normalize_concept_connector_columns.py
@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""Normalize connector, filter, select, and validity-date columns in concept JSON files.
+
+Connector columns of the form "table.column" become:
+  "table": "table",
+  "column": "column"
+
+Filter columns of the form "table.column" become:
+  "column": "column"
+
+Connector-select column references become local column names as well. This includes
+column, startColumn, endColumn, subtractColumn, distinctByColumn, distinctBy, and
+the values in flags maps.
+
+Validity-date column, startColumn, and endColumn references become local column
+names as well.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+
+def split_table_column(value: Any) -> tuple[str, str] | None:
+    if not isinstance(value, str):
+        return None
+    table, separator, column = value.partition(".")
+    if not separator or not table or not column:
+        return None
+    return table, column
+
+
+def set_connector_table_column(connector: dict[str, Any], table: str, column: str) -> None:
+    reordered: dict[str, Any] = {}
+    inserted = False
+    for key, value in connector.items():
+        if key == "column":
+            reordered["table"] = table
+            reordered["column"] = column
+            inserted = True
+        elif key != "table":
+            reordered[key] = value
+
+    if not inserted:
+        reordered["table"] = table
+        reordered["column"] = column
+
+    connector.clear()
+    connector.update(reordered)
+
+
+def normalize_column(value: Any) -> tuple[Any, int]:
+    split = split_table_column(value)
+    if split is None:
+        return value, 0
+    return split[1], 1
+
+
+def normalize_column_collection(value: Any) -> tuple[Any, int]:
+    if isinstance(value, list):
+        changed = 0
+        normalized = []
+        for item in value:
+            normalized_item, item_changes = normalize_column(item)
+            normalized.append(normalized_item)
+            changed += item_changes
+        return normalized, changed
+    return normalize_column(value)
+
+
+def normalize_definition_columns(
+    value: Any,
+    scalar_fields: tuple[str, ...],
+    collection_fields: tuple[str, ...],
+) -> int:
+    changed = 0
+    if isinstance(value, dict):
+        for field in scalar_fields:
+            if field in value:
+                value[field], field_changes = normalize_column(value[field])
+                changed += field_changes
+
+        for field in collection_fields:
+            if field in value:
+                value[field], field_changes = normalize_column_collection(value[field])
+                changed += field_changes
+
+        flags = value.get("flags")
+        if isinstance(flags, dict):
+            for key, column in flags.items():
+                flags[key], field_changes = normalize_column(column)
+                changed += field_changes
+
+        for child in value.values():
+            changed += normalize_definition_columns(child, scalar_fields, collection_fields)
+    elif isinstance(value, list):
+        for child in value:
+            changed += normalize_definition_columns(child, scalar_fields, collection_fields)
+    return changed
+
+
+def normalize_filter_columns(value: Any) -> int:
+    return normalize_definition_columns(value, ("column",), ("distinctByColumn",))
+
+
+def normalize_select_columns(value: Any) -> int:
+    return normalize_definition_columns(
+        value,
+        ("column", "startColumn", "endColumn", "subtractColumn"),
+        ("distinctByColumn", "distinctBy"),
+    )
+
+
+def normalize_validity_date_columns(value: Any) -> int:
+    return normalize_definition_columns(value, ("column", "startColumn", "endColumn"), ())
+
+
+def normalize_connectors(value: Any) -> tuple[int, int, int, int]:
+    connector_changes = 0
+    filter_changes = 0
+    select_changes = 0
+    validity_date_changes = 0
+
+    if isinstance(value, dict):
+        connectors = value.get("connectors")
+        connector_definitions = connectors if isinstance(connectors, list) else [connectors]
+        for connector in connector_definitions:
+            if not isinstance(connector, dict):
+                continue
+
+            split = split_table_column(connector.get("column"))
+            if split is not None:
+                set_connector_table_column(connector, split[0], split[1])
+                connector_changes += 1
+
+            filter_changes += normalize_filter_columns(connector.get("filters"))
+            select_changes += normalize_select_columns(connector.get("selects"))
+            validity_date_changes += normalize_validity_date_columns(connector.get("validityDates"))
+
+        for child in value.values():
+            child_connector_changes, child_filter_changes, child_select_changes, child_validity_date_changes = normalize_connectors(child)
+            connector_changes += child_connector_changes
+            filter_changes += child_filter_changes
+            select_changes += child_select_changes
+            validity_date_changes += child_validity_date_changes
+
+    elif isinstance(value, list):
+        for child in value:
+            child_connector_changes, child_filter_changes, child_select_changes, child_validity_date_changes = normalize_connectors(child)
+            connector_changes += child_connector_changes
+            filter_changes += child_filter_changes
+            select_changes += child_select_changes
+            validity_date_changes += child_validity_date_changes
+
+    return connector_changes, filter_changes, select_changes, validity_date_changes
+
+
+def normalize_file(path: Path, dry_run: bool) -> tuple[int, int, int, int]:
+    data = json.loads(path.read_text(encoding="utf-8"))
+    connector_changes, filter_changes, select_changes, validity_date_changes = normalize_connectors(data)
+
+    if not dry_run and (connector_changes or filter_changes or select_changes or validity_date_changes):
+        path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+    return connector_changes, filter_changes, select_changes, validity_date_changes
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Normalize table.column references in concept JSON files.")
+    parser.add_argument("concept_json", nargs="+", type=Path, help="Concept JSON file(s) to rewrite in place.")
+    parser.add_argument("--dry-run", action="store_true", help="Report changes without writing files.")
+    args = parser.parse_args()
+
+    for path in args.concept_json:
+        connector_changes, filter_changes, select_changes, validity_date_changes = normalize_file(path, args.dry_run)
+        action = "would update" if args.dry_run else "updated"
+        print(
+            f"{path}: {action} {connector_changes} connector column(s), "
+            f"{filter_changes} filter column(s), {select_changes} select column(s), "
+            f"{validity_date_changes} validity-date column(s)"
+        )
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/sql-connector/README.md b/sql-connector/README.md
new file mode 100644
index 0000000000..62d49ee2eb
--- /dev/null
+++ b/sql-connector/README.md
@@ -0,0 +1,56 @@
+# SQL connector
+
+This module contains the framework-neutral contract between query resolution and SQL compilation.
+
+## Resolved query model
+
+`ResolvedQuery` is an in-memory execution model. A producer must resolve and validate a request against one dataset
+catalog snapshot before constructing it. In particular:
+
+- logical references are replaced with physical tables and typed columns;
+- saved or reusable query references are expanded;
+- defaults and date-aggregation actions are materialized;
+- filter values, selects, conditions, validity dates, and secondary IDs are validated;
+- result columns are ordered and their presentation metadata is finalized.
+
+The SQL compiler may perform dialect capability checks, but it must not access a dataset repository or resolve logical
+identifiers. Connections, dialect implementations, compiler state, and execution services are intentionally not part of
+the resolved model.
+
+The module uses top-level packages as architectural boundaries:
+
+- `model` contains only the immutable, fully resolved compiler input;
+- `validation` contains Bean Validation constraints and the explicit validation boundary;
+- `compiler` contains framework-neutral compilation contracts, including the public dialect capabilities;
+- SQL conversion and execution implementations belong in sibling packages, not below `model`.
+
+The resolved model is organized by responsibility:
+
+- `model.node` contains the normalized query tree;
+- `model.operation` contains the open operation interfaces and standard implementations;
+- `model.schema` contains resolved physical tables, columns, connectors, and entity metadata;
+- `model.range` and `model.result` contain shared value objects.
+
+Shared dataset vocabulary such as `ColumnType` comes from the dependency-free `dataset-model` module. SQL-specific
+physical metadata remains in `model.schema`.
+
+`ResolvedFilter`, `ResolvedSelect`, `ResolvedCondition`, and `ResolvedAggregation` are open extension points.
+Implementations must be immutable and carry resolved columns and typed values. They must not carry unresolved repository
+identifiers or arbitrary SQL received from a query request.
+
+The `BuiltInFilters`, `BuiltInSelects`, `BuiltInConditions`, and `BuiltInAggregations` types define the normalized
+operations understood by the standard compiler. They intentionally describe semantics rather than the configuration
+classes used by a particular query-producing application.
+
+## Validation
+
+The resolved model uses Jakarta Bean Validation annotations. The application supplies a validation provider, normally
+Hibernate Validator, and calls `ResolvedQueryValidation` once before passing a query to the SQL compiler. Validation is
+cascaded through the complete query graph, including extension-provided filters, selects, conditions, and aggregations.
+
+Model records may reference declarative constraints from `validation`, but validation services must never enrich or
+rewrite the model. Conversion and execution code consumes a successfully validated `ResolvedQuery` and must not perform
+logical identifier resolution.
+
+Compact record constructors only create immutable copies of collections. Domain constraints such as compatible column
+types, ordered ranges, and same-table requirements are declarative and are reported together as constraint violations.
diff --git a/sql-connector/pom.xml b/sql-connector/pom.xml
new file mode 100644
index 0000000000..9da92ddf79
--- /dev/null
+++ b/sql-connector/pom.xml
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.bakdata.conquery</groupId>
+        <artifactId>parent</artifactId>
+        <version>${revision}</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+
+    <artifactId>sql-connector</artifactId>
+    <name>Conquery SQL Connector</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.bakdata.conquery</groupId>
+            <artifactId>dataset-model</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>jakarta.validation</groupId>
+            <artifactId>jakarta.validation-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.jooq</groupId>
+            <artifactId>jooq</artifactId>
+            <version>${jooq.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.hibernate.validator</groupId>
+            <artifactId>hibernate-validator</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish</groupId>
+            <artifactId>jakarta.el</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ColumnRole.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ColumnRole.java
new file mode 100644
index 0000000000..b95a879037
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ColumnRole.java
@@ -0,0 +1,11 @@
+package com.bakdata.conquery.sql.compiler;
+
+/** Describes how a compiled output column contributes to a result row. */
+public enum ColumnRole {
+
+	/** Column containing an entity identifier. Multiple columns may form a composite identifier. */
+	ENTITY_ID,
+
+	/** Query result value decoded and post-processed by the backend. */
+	RESULT
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/CompiledColumn.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/CompiledColumn.java
new file mode 100644
index 0000000000..88e368f327
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/CompiledColumn.java
@@ -0,0 +1,22 @@
+package com.bakdata.conquery.sql.compiler;
+
+import com.bakdata.conquery.sql.model.result.ResultType;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+
+/**
+ * Ordered description of one column produced by a {@link CompiledQuery}.
+ *
+ * @param outputId stable, backend-independent key used to correlate the column with backend metadata
+ * @param sqlAlias alias rendered into the SQL statement
+ * @param type logical value type expected by backend result decoding
+ * @param role role of the column in the result row
+ */
+public record CompiledColumn(
+		@NotBlank String outputId,
+		@NotBlank String sqlAlias,
+		@NotNull @Valid ResultType type,
+		@NotNull ColumnRole role
+) {
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/CompiledQuery.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/CompiledQuery.java
new file mode 100644
index 0000000000..1e8faac0c0
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/CompiledQuery.java
@@ -0,0 +1,42 @@
+package com.bakdata.conquery.sql.compiler;
+
+import java.util.List;
+
+import com.bakdata.conquery.sql.model.internal.ModelNormalization;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.AssertTrue;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+
+/**
+ * Self-contained result of SQL compilation.
+ *
+ * <p>The backend executes {@link #sql()} and uses the ordered {@link #columns()} to correlate and decode the JDBC
+ * result. Datasource selection, execution, and result post-processing are deliberately excluded.</p>
+ */
+public record CompiledQuery(
+		@NotBlank String sql,
+		@NotEmpty List<@NotNull @Valid CompiledColumn> columns
+) {
+
+	public CompiledQuery {
+		columns = ModelNormalization.immutableCopy(columns);
+	}
+
+	@AssertTrue(message = "compiled column outputIds must be unique")
+	public boolean isOutputIdsUnique() {
+		return columns == null || columns.stream()
+				.map(CompiledColumn::outputId)
+				.distinct()
+				.count() == columns.size();
+	}
+
+	@AssertTrue(message = "compiled column SQL aliases must be unique")
+	public boolean isSqlAliasesUnique() {
+		return columns == null || columns.stream()
+				.map(CompiledColumn::sqlAlias)
+				.distinct()
+				.count() == columns.size();
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/SqlCompiler.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/SqlCompiler.java
new file mode 100644
index 0000000000..1c6bc06076
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/SqlCompiler.java
@@ -0,0 +1,17 @@
+package com.bakdata.conquery.sql.compiler;
+
+import com.bakdata.conquery.sql.compiler.dialect.CompilerDialect;
+import com.bakdata.conquery.sql.model.ResolvedQuery;
+
+/**
+ * Compiles a fully resolved query into self-contained SQL for a selected database dialect.
+ *
+ * <p>The caller owns dataset and datasource selection, query execution, and result post-processing. Implementations
+ * must compile exclusively from the supplied query and dialect and must not resolve identifiers or access backend
+ * repositories.</p>
+ */
+@FunctionalInterface
+public interface SqlCompiler {
+
+	CompiledQuery compile(ResolvedQuery query, CompilerDialect dialect);
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/dialect/CompilerDialect.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/dialect/CompilerDialect.java
new file mode 100644
index 0000000000..53ac40268e
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/dialect/CompilerDialect.java
@@ -0,0 +1,44 @@
+package com.bakdata.conquery.sql.compiler.dialect;
+
+import java.sql.Date;
+
+import org.jooq.Field;
+
+/**
+ * Database-specific capabilities exposed to the framework-neutral SQL compiler.
+ *
+ * <p>This contract belongs to the SQL connector and must only use types owned by the connector or its public model
+ * dependencies. Backend query DTOs, converter registries, runtime connections, and result processing are deliberately
+ * excluded.</p>
+ *
+ * <p>Concrete backend integrations may extend this contract with temporary adapter interfaces while the legacy compiler
+ * is migrated. Those adapters must not become dependencies of the framework-neutral compiler.</p>
+ */
+public interface CompilerDialect {
+
+	/**
+	 * Aggregate a field to an arbitrary value from its group.
+	 *
+	 * <p>The exact expression is dialect-specific. For example, a database without an {@code ANY_VALUE} aggregate may
+	 * use {@code MIN} as an equivalent deterministic representative where the compiler only requires one value.</p>
+	 */
+	<T> Field<T> anyValue(Field<T> field);
+
+	/**
+	 * Render the bounds of one date range into the database-specific physical result representation.
+	 */
+	Field<?> renderDateRange(Field<Date> start, Field<Date> end);
+
+	/**
+	 * Aggregate multiple date ranges into the database-specific physical result representation.
+	 */
+	Field<?> aggregateDateRanges(Field<Date> start, Field<Date> end);
+
+	/** Maximum identifier length supported by the target database. */
+	int getNameMaxLength();
+
+	/** Whether the dialect represents date ranges in one database column instead of separate start and end columns. */
+	default boolean supportsSingleColumnRanges() {
+		return false;
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/dialect/package-info.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/dialect/package-info.java
new file mode 100644
index 0000000000..fbdeb27198
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/dialect/package-info.java
@@ -0,0 +1,2 @@
+/** Database-specific capabilities exposed through the SQL compiler API. */
+package com.bakdata.conquery.sql.compiler.dialect;
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/Qualifiable.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/Qualifiable.java
new file mode 100644
index 0000000000..092dce642a
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/Qualifiable.java
@@ -0,0 +1,7 @@
+package com.bakdata.conquery.sql.compiler.ir;
+
+/** An intermediate representation that can be rebound to a qualified SQL table or CTE name. */
+public interface Qualifiable<T> {
+
+	T qualify(String qualifier);
+}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/QualifyingUtil.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/QualifyingUtil.java
similarity index 52%
rename from backend/src/main/java/com/bakdata/conquery/sql/conversion/model/QualifyingUtil.java
rename to sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/QualifyingUtil.java
index a4665c4957..6c593d3253 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/QualifyingUtil.java
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/QualifyingUtil.java
@@ -1,13 +1,17 @@
-package com.bakdata.conquery.sql.conversion.model;
+package com.bakdata.conquery.sql.compiler.ir;
 
 import java.util.List;
 import java.util.stream.Collectors;
 
-import com.bakdata.conquery.sql.conversion.model.select.SqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
 import org.jooq.Field;
 import org.jooq.impl.DSL;
 
-public class QualifyingUtil {
+/** Utilities for rebinding compiler IR fields and selects to a table or CTE qualifier. */
+public final class QualifyingUtil {
+
+	private QualifyingUtil() {
+	}
 
 	public static <T> Field<T> qualify(Field<T> field, String qualifier) {
 		return DSL.field(DSL.name(qualifier, field.getName()), field.getType());
@@ -15,8 +19,7 @@ public static <T> Field<T> qualify(Field<T> field, String qualifier) {
 
 	public static List<SqlSelect> qualify(List<SqlSelect> sqlSelects, String qualifier) {
 		return sqlSelects.stream()
-						 .map(sqlSelect -> sqlSelect.qualify(qualifier))
-						 .collect(Collectors.toList());
+				.map(sqlSelect -> sqlSelect.qualify(qualifier))
+				.collect(Collectors.toList());
 	}
-
 }
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/Selects.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/Selects.java
new file mode 100644
index 0000000000..de5e7a55d8
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/Selects.java
@@ -0,0 +1,92 @@
+package com.bakdata.conquery.sql.compiler.ir;
+
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
+import lombok.Builder;
+import lombok.Singular;
+import lombok.Value;
+import org.jooq.Field;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Fields selected by a compiler step before dialect-specific rendering.
+ *
+ * <p>This type only describes and transforms compiler state. Turning date ranges and select expressions into the
+ * final SQL projection belongs to the compiler layer that owns the dialect.</p>
+ */
+@Value
+@Builder(toBuilder = true)
+public class Selects {
+
+	SqlIdColumns ids;
+	@Builder.Default
+	Optional<ColumnDateRange> validityDate = Optional.empty();
+	@Builder.Default
+	Optional<ColumnDateRange> stratificationDate = Optional.empty();
+	@Singular
+	List<SqlSelect> sqlSelects;
+
+	public Selects blockValidityDate() {
+		return this.toBuilder()
+				.validityDate(Optional.empty())
+				.build();
+	}
+
+	public Selects qualify(String qualifier) {
+		SqlIdColumns qualifiedIds = this.ids.qualify(qualifier);
+		List<SqlSelect> qualifiedSqlSelects = this.sqlSelects.stream()
+				.map(sqlSelect -> sqlSelect.qualify(qualifier))
+				.toList();
+
+		return Selects.builder()
+				.ids(qualifiedIds)
+				.validityDate(this.validityDate.map(dateRange -> dateRange.qualify(qualifier)))
+				.stratificationDate(this.stratificationDate.map(dateRange -> dateRange.qualify(qualifier)))
+				.sqlSelects(qualifiedSqlSelects)
+				.build();
+	}
+
+	public List<Field<?>> all() {
+		return Stream.of(
+						this.ids.toFields().stream(),
+						this.stratificationDate.stream().flatMap(range -> range.toFields().stream()),
+						this.validityDate.stream().flatMap(range -> range.toFields().stream()),
+						this.sqlSelects.stream().flatMap(sqlSelect -> sqlSelect.toFields().stream())
+				)
+				.flatMap(Function.identity())
+				.map(select -> (Field<?>) select)
+				.distinct()
+				.collect(Collectors.toList());
+	}
+
+	/**
+	 * All fields that have not been explicitly selected (IDs, validity/stratification dates).
+	 */
+	public List<Field<?>> nonExplicitSelects() {
+		return Stream.of(
+						this.ids.toFields().stream(),
+						this.stratificationDate.stream().flatMap(range -> range.toFields().stream()),
+						this.validityDate.stream().flatMap(range -> range.toFields().stream())
+				)
+				.flatMap(Function.identity())
+				.map(select -> (Field<?>) select)
+				.distinct()
+				.collect(Collectors.toList());
+	}
+
+	/**
+	 * All explicitly selected and converted fields.
+	 */
+	public List<Field<?>> explicitSelects() {
+		return this.sqlSelects.stream()
+				.flatMap(sqlSelect -> sqlSelect.toFields().stream())
+				.distinct()
+				.collect(Collectors.toList());
+	}
+
+}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/SharedAliases.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/SharedAliases.java
similarity index 76%
rename from backend/src/main/java/com/bakdata/conquery/sql/conversion/SharedAliases.java
rename to sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/SharedAliases.java
index 191d96ecae..ff1cf3167e 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/SharedAliases.java
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/SharedAliases.java
@@ -1,10 +1,6 @@
-package com.bakdata.conquery.sql.conversion;
+package com.bakdata.conquery.sql.compiler.ir;
 
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-
-@Getter
-@RequiredArgsConstructor
+/** Shared SQL aliases used by compiler transformations and their generated output columns. */
 public enum SharedAliases {
 
 	PRIMARY_COLUMN("primary_id"),
@@ -13,7 +9,6 @@ public enum SharedAliases {
 
 	NOP_TABLE("nop_table"),
 
-	// form related
 	INDEX_START("index_start"),
 	QUARTER_START("quarter_start"),
 	QUARTER_END("quarter_end"),
@@ -32,8 +27,15 @@ public enum SharedAliases {
 	STRATIFICATION_BOUNDS("stratification_bounds"),
 	OBSERVATION_SCOPE("scope"),
 
-	// full export form
 	SOURCE("source");
 
 	private final String alias;
+
+	SharedAliases(String alias) {
+		this.alias = alias;
+	}
+
+	public String getAlias() {
+		return alias;
+	}
 }
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/SqlIdColumns.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/SqlIdColumns.java
new file mode 100644
index 0000000000..bfb122a4a2
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/SqlIdColumns.java
@@ -0,0 +1,137 @@
+package com.bakdata.conquery.sql.compiler.ir;
+
+import java.sql.Date;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import org.jooq.Condition;
+import org.jooq.Field;
+import org.jooq.impl.DSL;
+
+/** Compiler IR for the columns identifying an entity. */
+public class SqlIdColumns implements Qualifiable<SqlIdColumns> {
+
+	private final Field<String> primaryColumn;
+	private final Field<String> secondaryId;
+	private final SqlIdColumns predecessor;
+
+	public SqlIdColumns(Field<String> primaryColumn, Field<String> secondaryId) {
+		this(primaryColumn, secondaryId, null);
+	}
+
+	public SqlIdColumns(Field<String> primaryColumn) {
+		this(primaryColumn, null, null);
+	}
+
+	protected SqlIdColumns(Field<String> primaryColumn, Field<String> secondaryId, SqlIdColumns predecessor) {
+		this.primaryColumn = primaryColumn;
+		this.secondaryId = secondaryId;
+		this.predecessor = predecessor;
+	}
+
+	public Field<String> getPrimaryColumn() {
+		return primaryColumn;
+	}
+
+	public SqlIdColumns withAlias() {
+		Field<String> primary = primaryColumn.as(SharedAliases.PRIMARY_COLUMN.getAlias());
+		if (secondaryId == null) {
+			return new SqlIdColumns(primary, null, this);
+		}
+		return new SqlIdColumns(primary, secondaryId.as(SharedAliases.SECONDARY_ID.getAlias()), this);
+	}
+
+	@Override
+	public SqlIdColumns qualify(String qualifier) {
+		Field<String> primary = QualifyingUtil.qualify(primaryColumn, qualifier);
+		if (secondaryId == null) {
+			return new SqlIdColumns(primary, null, this);
+		}
+		return new SqlIdColumns(primary, QualifyingUtil.qualify(secondaryId, qualifier), this);
+	}
+
+	public SqlIdColumns withStratification(String resolution, Field<Integer> index) {
+		return withStratification(resolution, index, null);
+	}
+
+	/**
+	 * Add stratification columns using a backend-independent resolution token.
+	 *
+	 * @param resolution normalized resolution value supplied at the compiler boundary
+	 * @param index stratification index
+	 * @param eventDate optional event date used by relative stratification
+	 */
+	public SqlIdColumns withStratification(String resolution, Field<Integer> index, Field<Date> eventDate) {
+		Field<String> resolutionField = DSL.inline(resolution).as(SharedAliases.RESOLUTION.getAlias());
+		return new StratificationSqlIdColumns(primaryColumn, resolutionField, index, eventDate);
+	}
+
+	/** Convert stratified IDs into their final output form using the normalized complete-resolution token. */
+	public SqlIdColumns forFinalSelect(String completeResolution) {
+		return this;
+	}
+
+	public Optional<Field<String>> getSecondaryId() {
+		return Optional.ofNullable(secondaryId);
+	}
+
+	public Optional<SqlIdColumns> getPredecessor() {
+		return Optional.ofNullable(predecessor);
+	}
+
+	public boolean isWithStratification() {
+		return false;
+	}
+
+	public List<Field<?>> toFields() {
+		if (secondaryId == null) {
+			return List.of(primaryColumn);
+		}
+		return List.of(primaryColumn, secondaryId);
+	}
+
+	public List<Condition> join(SqlIdColumns rightIds) {
+		Condition joinPrimaries = primaryColumn.eq(rightIds.primaryColumn);
+		Condition joinSecondaries = getSecondaryId()
+				.flatMap(leftSecondary -> rightIds.getSecondaryId().map(leftSecondary::eq))
+				.orElse(DSL.noCondition());
+		return List.of(joinPrimaries, joinSecondaries);
+	}
+
+	public SqlIdColumns coalesce(List<SqlIdColumns> selectsIds) {
+		List<Field<String>> primaryColumns = new ArrayList<>();
+		List<Field<String>> secondaryIds = new ArrayList<>();
+
+		primaryColumns.add(primaryColumn);
+		getSecondaryId().ifPresent(secondaryIds::add);
+		selectsIds.forEach(ids -> {
+			primaryColumns.add(ids.primaryColumn);
+			ids.getSecondaryId().ifPresent(secondaryIds::add);
+		});
+
+		Field<String> coalescedPrimary = coalesceFields(primaryColumns, String.class)
+				.coerce(String.class)
+				.as(SharedAliases.PRIMARY_COLUMN.getAlias());
+		if (secondaryIds.isEmpty()) {
+			return new SqlIdColumns(coalescedPrimary);
+		}
+		Field<String> coalescedSecondary = coalesceFields(secondaryIds, String.class)
+				.coerce(String.class)
+				.as(SharedAliases.SECONDARY_ID.getAlias());
+		return new SqlIdColumns(coalescedPrimary, coalescedSecondary);
+	}
+
+	protected static <T> Field<T> coalesceFields(List<? extends Field<?>> fields, Class<T> type) {
+		Field<T> result = fields.getFirst().coerce(type);
+		for (int index = 1; index < fields.size(); index++) {
+			result = DSL.coalesce(result, fields.get(index).coerce(type));
+		}
+		return result;
+	}
+
+	@Override
+	public String toString() {
+		return "SqlIdColumns(primaryColumn=%s, secondaryId=%s)".formatted(primaryColumn, secondaryId);
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/StratificationSqlIdColumns.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/StratificationSqlIdColumns.java
new file mode 100644
index 0000000000..61f70fa8e3
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/StratificationSqlIdColumns.java
@@ -0,0 +1,113 @@
+package com.bakdata.conquery.sql.compiler.ir;
+
+import java.sql.Date;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+import org.jooq.Condition;
+import org.jooq.Field;
+import org.jooq.impl.DSL;
+
+/** Stratified ID-column representation used internally by the compiler. */
+final class StratificationSqlIdColumns extends SqlIdColumns {
+
+	private final Field<String> resolution;
+	private final Field<Integer> index;
+	private final Field<Date> eventDate;
+
+	StratificationSqlIdColumns(Field<String> primaryColumn, Field<String> resolution, Field<Integer> index, Field<Date> eventDate) {
+		super(primaryColumn);
+		this.resolution = resolution;
+		this.index = index;
+		this.eventDate = eventDate;
+	}
+
+	@Override
+	public SqlIdColumns qualify(String qualifier) {
+		Field<Date> qualifiedEventDate = eventDate == null ? null : QualifyingUtil.qualify(eventDate, qualifier);
+		return new StratificationSqlIdColumns(
+				QualifyingUtil.qualify(getPrimaryColumn(), qualifier),
+				QualifyingUtil.qualify(resolution, qualifier),
+				QualifyingUtil.qualify(index, qualifier),
+				qualifiedEventDate
+		);
+	}
+
+	@Override
+	public SqlIdColumns forFinalSelect(String completeResolution) {
+		Field<Integer> finalIndex = DSL.when(
+				resolution.eq(DSL.inline(completeResolution)),
+				DSL.inline(null, Integer.class)
+		)
+				.otherwise(index)
+				.as(SharedAliases.INDEX.getAlias());
+		return new StratificationSqlIdColumns(getPrimaryColumn(), resolution, finalIndex, eventDate);
+	}
+
+	@Override
+	public boolean isWithStratification() {
+		return true;
+	}
+
+	@Override
+	public List<Field<?>> toFields() {
+		return Stream.<Field<?>>of(getPrimaryColumn(), resolution, index, eventDate)
+				.filter(Objects::nonNull)
+				.toList();
+	}
+
+	@Override
+	public List<Condition> join(SqlIdColumns rightIds) {
+		if (!(rightIds instanceof StratificationSqlIdColumns right)) {
+			return super.join(rightIds);
+		}
+
+		Condition joinResolutionAndIndex = resolution.eq(right.resolution).and(index.eq(right.index));
+		Condition joinEventDate = eventDate == null ? DSL.noCondition() : eventDate.eq(right.eventDate);
+		return Stream.concat(super.join(rightIds).stream(), Stream.of(joinResolutionAndIndex, joinEventDate)).toList();
+	}
+
+	@Override
+	public SqlIdColumns coalesce(List<SqlIdColumns> selectsIds) {
+		if (!selectsIds.stream().allMatch(StratificationSqlIdColumns.class::isInstance)) {
+			throw new IllegalArgumentException("Can only coalesce SqlIdColumns if all are with stratification");
+		}
+
+		List<Field<String>> primaryColumns = new ArrayList<>();
+		List<Field<String>> resolutions = new ArrayList<>();
+		List<Field<Integer>> indices = new ArrayList<>();
+		List<Field<?>> eventDates = new ArrayList<>();
+
+		primaryColumns.add(getPrimaryColumn());
+		resolutions.add(resolution);
+		indices.add(index);
+		if (eventDate != null) {
+			eventDates.add(eventDate);
+		}
+
+		for (SqlIdColumns ids : selectsIds) {
+			StratificationSqlIdColumns stratified = (StratificationSqlIdColumns) ids;
+			primaryColumns.add(stratified.getPrimaryColumn());
+			resolutions.add(stratified.resolution);
+			indices.add(stratified.index);
+			if (stratified.eventDate != null) {
+				eventDates.add(stratified.eventDate);
+			}
+		}
+
+		Field<String> primary = coalesceFields(primaryColumns, String.class)
+				.coerce(String.class)
+				.as(SharedAliases.PRIMARY_COLUMN.getAlias());
+		Field<String> coalescedResolution = coalesceFields(resolutions, String.class)
+				.as(SharedAliases.RESOLUTION.getAlias());
+		Field<Integer> coalescedIndex = coalesceFields(indices, Integer.class)
+				.as(SharedAliases.INDEX.getAlias());
+		Field<Date> coalescedEventDate = eventDates.isEmpty()
+				? null
+				: coalesceFields(eventDates, Date.class).as(SharedAliases.INDEX_SELECTOR.getAlias());
+
+		return new StratificationSqlIdColumns(primary, coalescedResolution, coalescedIndex, coalescedEventDate);
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/package-info.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/package-info.java
new file mode 100644
index 0000000000..416eb14035
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/package-info.java
@@ -0,0 +1,7 @@
+/**
+ * Internal representations produced and transformed while compiling a resolved query.
+ *
+ * <p>Types in this package and its subpackages are implementation details of {@code sql-connector}, not integration
+ * contracts for backends or plugins. Backend references may exist temporarily while the legacy compiler is migrated.</p>
+ */
+package com.bakdata.conquery.sql.compiler.ir;
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/ColumnDateRange.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/ColumnDateRange.java
new file mode 100644
index 0000000000..977b4508f3
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/ColumnDateRange.java
@@ -0,0 +1,98 @@
+package com.bakdata.conquery.sql.compiler.ir.select;
+
+import java.sql.Date;
+import java.util.List;
+
+import com.bakdata.conquery.sql.compiler.ir.QualifyingUtil;
+import org.jooq.Condition;
+import org.jooq.Field;
+import org.jooq.impl.DSL;
+
+/** A two-column date-range representation used by compiler transformations. */
+public final class ColumnDateRange implements SqlSelect {
+
+	private static final String VALIDITY_DATE_COLUMN_NAME_SUFFIX = "_validity_date";
+	private static final String START_SUFFIX = "_start";
+	private static final String END_SUFFIX = "_end";
+
+	private final Field<Date> start;
+	private final Field<Date> end;
+	private final String alias;
+
+	private ColumnDateRange(Field<Date> start, Field<Date> end, String alias) {
+		this.start = start;
+		this.end = end;
+		this.alias = alias;
+	}
+
+	public static ColumnDateRange of(Field<Date> start, Field<Date> end) {
+		return new ColumnDateRange(start, end, "");
+	}
+
+	public static ColumnDateRange of(Field<Date> start, Field<Date> end, String alias) {
+		return new ColumnDateRange(start, end, alias);
+	}
+
+	public Field<Date> getStart() {
+		return start;
+	}
+
+	public Field<Date> getEnd() {
+		return end;
+	}
+
+	public String getAlias() {
+		return alias;
+	}
+
+	public ColumnDateRange asValidityDateRange(String alias) {
+		return as(alias + VALIDITY_DATE_COLUMN_NAME_SUFFIX);
+	}
+
+	@Override
+	public List<Field<?>> toFields() {
+		return List.of(start, end);
+	}
+
+	@Override
+	public ColumnDateRange qualify(String qualifier) {
+		return new ColumnDateRange(
+				QualifyingUtil.qualify(start, qualifier),
+				QualifyingUtil.qualify(end, qualifier),
+				alias
+		);
+	}
+
+	@Override
+	public List<String> requiredColumns() {
+		return toFields().stream()
+				.map(Field::getName)
+				.distinct()
+				.toList();
+	}
+
+	public ColumnDateRange as(String alias) {
+		return new ColumnDateRange(start.as(alias + START_SUFFIX), end.as(alias + END_SUFFIX), alias);
+	}
+
+	public ColumnDateRange coalesce(ColumnDateRange right) {
+		return ColumnDateRange.of(DSL.coalesce(start, right.start), DSL.coalesce(end, right.end)).as(alias);
+	}
+
+	public Condition join(ColumnDateRange right) {
+		return start.eq(right.start).and(end.eq(right.end));
+	}
+
+	public Condition isNotNull() {
+		return start.isNotNull().and(end.isNotNull());
+	}
+
+	public static Condition isNotEmpty(ColumnDateRange columnDateRange) {
+		return columnDateRange.start.isNotNull().and(columnDateRange.end.isNotNull());
+	}
+
+	@Override
+	public String toString() {
+		return "ColumnDateRange(start=%s, end=%s)".formatted(start, end);
+	}
+}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ExistsSqlSelect.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/ExistsSqlSelect.java
similarity index 58%
rename from backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ExistsSqlSelect.java
rename to sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/ExistsSqlSelect.java
index b6a15eaab5..a09b60e79a 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/ExistsSqlSelect.java
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/ExistsSqlSelect.java
@@ -1,18 +1,18 @@
-package com.bakdata.conquery.sql.conversion.model.select;
+package com.bakdata.conquery.sql.compiler.ir.select;
 
-import com.bakdata.conquery.sql.conversion.dialect.SqlFunctionProvider;
-import lombok.AccessLevel;
-import lombok.RequiredArgsConstructor;
-import org.jooq.Field;
-import org.jooq.Name;
+import static org.jooq.impl.DSL.coalesce;
+import static org.jooq.impl.DSL.field;
+import static org.jooq.impl.DSL.inline;
+import static org.jooq.impl.DSL.max;
+import static org.jooq.impl.DSL.name;
 
-import java.util.Collections;
 import java.util.List;
 
-import static org.jooq.impl.DSL.*;
-import static org.jooq.impl.DSL.field;
+import com.bakdata.conquery.sql.compiler.dialect.CompilerDialect;
+import org.jooq.Field;
+import org.jooq.Name;
 
-@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+/** A single-column marker select indicating whether a row exists. */
 public class ExistsSqlSelect implements SingleColumnSqlSelect {
 
 	private static final Field<Integer> EXISTS = inline(1);
@@ -20,13 +20,18 @@ public class ExistsSqlSelect implements SingleColumnSqlSelect {
 	private final Field<Integer> exists;
 	private final Name alias;
 
-	public static ExistsSqlSelect withAlias(final String alias) {
+	private ExistsSqlSelect(Field<Integer> exists, Name alias) {
+		this.exists = exists;
+		this.alias = alias;
+	}
+
+	public static ExistsSqlSelect withAlias(String alias) {
 		return new ExistsSqlSelect(EXISTS.as(alias), name(alias));
 	}
 
 	@Override
 	public List<String> requiredColumns() {
-		return Collections.emptyList();
+		return List.of();
 	}
 
 	@Override
@@ -45,8 +50,8 @@ public Field<Integer> aliased() {
 	}
 
 	@Override
-	public SingleColumnSqlSelect qualify(final String qualifier) {
-		final Field<Integer> qualified = field(name(name(qualifier), alias), exists.getType());
+	public SingleColumnSqlSelect qualify(String qualifier) {
+		Field<Integer> qualified = field(name(name(qualifier), alias), exists.getType());
 		return new ExistsSqlSelect(qualified, alias);
 	}
 
@@ -61,8 +66,8 @@ public SqlSelect toFinalRepresentation() {
 	}
 
 	@Override
-	public List<Field<?>> aggregateForFinalQuery(SqlFunctionProvider functionProvider) {
-		// We have to coalesce at the end of the query because full-outer-joins will create null values, which we want to avoid.
+	public List<Field<?>> aggregateForFinalQuery(CompilerDialect dialect) {
+		// Full outer joins can introduce null values, which an existence marker represents as zero.
 		Field<Integer> coalesced = coalesce(max(select()), inline(0));
 		return List.of(coalesced.as(alias));
 	}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/ExtractingSqlSelect.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/ExtractingSqlSelect.java
new file mode 100644
index 0000000000..15719254e1
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/ExtractingSqlSelect.java
@@ -0,0 +1,31 @@
+package com.bakdata.conquery.sql.compiler.ir.select;
+
+import java.util.List;
+
+import org.jooq.Field;
+import org.jooq.impl.DSL;
+
+/** A single-column select that references an existing column. */
+public record ExtractingSqlSelect<T>(String table, String column, Class<T> columnClass) implements SingleColumnSqlSelect {
+
+	@Override
+	public Field<T> select() {
+		return DSL.field(DSL.name(table, column), columnClass);
+	}
+
+	@Override
+	public Field<T> aliased() {
+		return DSL.field(DSL.name(column), columnClass);
+	}
+
+	@Override
+	public List<String> requiredColumns() {
+		return List.of(column);
+	}
+
+	@Override
+	public ExtractingSqlSelect<T> qualify(String qualifier) {
+		Field<T> aliased = aliased();
+		return new ExtractingSqlSelect<>(qualifier, aliased.getName(), aliased.getType());
+	}
+}
diff --git a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/FieldWrapper.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/FieldWrapper.java
similarity index 51%
rename from backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/FieldWrapper.java
rename to sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/FieldWrapper.java
index 42a877a2e0..c7cc871f02 100644
--- a/backend/src/main/java/com/bakdata/conquery/sql/conversion/model/select/FieldWrapper.java
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/FieldWrapper.java
@@ -1,34 +1,27 @@
-package com.bakdata.conquery.sql.conversion.model.select;
+package com.bakdata.conquery.sql.compiler.ir.select;
 
 import java.util.List;
+import java.util.Objects;
 
-import lombok.EqualsAndHashCode;
 import org.jooq.Field;
 import org.jooq.impl.DSL;
 
-/**
- * Wrapper for a {@link Field}.
- */
-@EqualsAndHashCode
+/** A single-column select backed by an arbitrary jOOQ field expression. */
 public class FieldWrapper<T> implements SingleColumnSqlSelect {
 
 	private final Field<T> field;
-	@EqualsAndHashCode.Exclude
 	private final List<String> requiredColumns;
 
 	/**
-	 * @param field           The field to wrap, e.g. {@code DSL.sum(DSL.field(DSL.name("foo", "bar"))).as("foo_bar")};
-	 * @param requiredColumns All columns this {@link FieldWrapper} requires in the previous CTE/table to be present.
+	 * @param field           field to wrap
+	 * @param requiredColumns columns that must be present in the preceding table or CTE
 	 */
 	public FieldWrapper(Field<T> field, String... requiredColumns) {
 		this.field = field;
 		this.requiredColumns = List.of(requiredColumns);
 	}
 
-	/**
-	 * @param field @param field The field to wrap, e.g. {@code DSL.field(DSL.name("fizz", "buzz"))).as("fizz_buzz")}; The column for
-	 * {@link FieldWrapper#requiredColumns()} will be taken from the alias of the wrapped field.
-	 */
+	/** Create a wrapper whose required column is derived from the field alias. */
 	public FieldWrapper(Field<T> field) {
 		this.field = field;
 		this.requiredColumns = List.of(field.getName());
@@ -46,17 +39,28 @@ public Field<T> aliased() {
 
 	@Override
 	public List<String> requiredColumns() {
-		return this.requiredColumns;
+		return requiredColumns;
 	}
 
 	@Override
 	public ExtractingSqlSelect<T> qualify(String qualifier) {
 		Field<T> aliased = aliased();
-		return new ExtractingSqlSelect<>(
-				qualifier,
-				aliased.getName(),
-				aliased.getType()
-		);
+		return new ExtractingSqlSelect<>(qualifier, aliased.getName(), aliased.getType());
 	}
 
+	@Override
+	public boolean equals(Object object) {
+		if (this == object) {
+			return true;
+		}
+		if (!(object instanceof FieldWrapper<?> that)) {
+			return false;
+		}
+		return Objects.equals(field, that.field);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(field);
+	}
 }
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/SingleColumnSqlSelect.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/SingleColumnSqlSelect.java
new file mode 100644
index 0000000000..b75c2ece99
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/SingleColumnSqlSelect.java
@@ -0,0 +1,28 @@
+package com.bakdata.conquery.sql.compiler.ir.select;
+
+import java.util.List;
+
+import org.jooq.Field;
+
+/** Intermediate select represented by one SQL field. */
+public interface SingleColumnSqlSelect extends SqlSelect {
+
+	/**
+	 * @return the complete aliased SQL expression, for example
+	 * {@code DSL.firstValue(DSL.field(DSL.name("foo", "bar"))).as("foobar")}
+	 */
+	Field<?> select();
+
+	/**
+	 * @return the aliased column reference, for example {@code DSL.field("foobar")}
+	 */
+	Field<?> aliased();
+
+	@Override
+	SingleColumnSqlSelect qualify(String qualifier);
+
+	@Override
+	default List<Field<?>> toFields() {
+		return List.of(select());
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/SqlSelect.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/SqlSelect.java
new file mode 100644
index 0000000000..6c7f1a47c0
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/SqlSelect.java
@@ -0,0 +1,38 @@
+package com.bakdata.conquery.sql.compiler.ir.select;
+
+import java.util.List;
+
+import com.bakdata.conquery.sql.compiler.dialect.CompilerDialect;
+import com.bakdata.conquery.sql.compiler.ir.Qualifiable;
+import org.jooq.Field;
+
+/** Intermediate representation of one or more SQL select expressions. */
+public interface SqlSelect extends Qualifiable<SqlSelect> {
+
+	List<Field<?>> toFields();
+
+	/** All column names this select requires. */
+	List<String> requiredColumns();
+
+	/** Whether this select only occurs in the final concept CTE and has no preceding select. */
+	default boolean isUniversal() {
+		return false;
+	}
+
+	/** Apply an extra aggregation required when joining this select across connectors. */
+	default SqlSelect connectorAggregate() {
+		return this;
+	}
+
+	/** Convert this select into the representation returned by the final SQL query. */
+	default SqlSelect toFinalRepresentation() {
+		return this;
+	}
+
+	/** Aggregate this select to one value per ID group in the final concept query. */
+	default List<Field<?>> aggregateForFinalQuery(CompilerDialect dialect) {
+		return toFinalRepresentation().toFields().stream()
+				.<Field<?>>map(field -> dialect.anyValue(field).as(field.getName()))
+				.toList();
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/package-info.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/package-info.java
new file mode 100644
index 0000000000..b61bb2c072
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/ir/select/package-info.java
@@ -0,0 +1,2 @@
+/** Internal SQL select expressions used while compiling a resolved query. */
+package com.bakdata.conquery.sql.compiler.ir.select;
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/package-info.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/package-info.java
new file mode 100644
index 0000000000..86869b1af8
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/package-info.java
@@ -0,0 +1,5 @@
+/**
+ * Framework-neutral contracts for compiling resolved queries into self-contained SQL and an ordered physical result
+ * layout. Dataset and datasource selection, query execution, and result post-processing are backend responsibilities.
+ */
+package com.bakdata.conquery.sql.compiler;
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/rendering/SelectProjectionRenderer.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/rendering/SelectProjectionRenderer.java
new file mode 100644
index 0000000000..ad1a4734a8
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/rendering/SelectProjectionRenderer.java
@@ -0,0 +1,69 @@
+package com.bakdata.conquery.sql.compiler.rendering;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import com.bakdata.conquery.sql.compiler.dialect.CompilerDialect;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SharedAliases;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
+import org.jooq.Field;
+
+/** Renders a select projection from compiler IR into database-specific physical fields. */
+public final class SelectProjectionRenderer {
+
+	private SelectProjectionRenderer() {
+	}
+
+	/**
+	 * Render the final projection fields.
+	 *
+	 * @param selects compiler projection state
+	 * @param dialect database-specific compiler capabilities
+	 * @param validityDateRendering whether validity ranges represent individual or grouped rows
+	 */
+	public static List<Field<?>> render(
+			Selects selects,
+			CompilerDialect dialect,
+			ValidityDateRendering validityDateRendering
+	) {
+		Optional<Field<?>> validityDateRendered = selects.getValidityDate()
+				.map(dateRange -> renderValidityDate(dateRange, dialect, validityDateRendering)
+						.as(SharedAliases.DATES_COLUMN.getAlias()));
+
+		Optional<Field<?>> stratificationDateRendered = selects.getStratificationDate()
+				.map(dateRange -> dialect.renderDateRange(dateRange.getStart(), dateRange.getEnd())
+						.as(SharedAliases.STRATIFICATION_BOUNDS.getAlias()));
+
+		return Stream.of(
+						selects.getIds().toFields().stream(),
+						stratificationDateRendered.stream(),
+						validityDateRendered.stream(),
+						selects.getSqlSelects().stream().flatMap(sqlSelect -> sqlSelect.toFinalRepresentation().toFields().stream())
+				)
+				.flatMap(Function.identity())
+				.map(select -> (Field<?>) select)
+				.distinct()
+				.collect(Collectors.toList());
+	}
+
+	private static Field<?> renderValidityDate(
+			ColumnDateRange dateRange,
+			CompilerDialect dialect,
+			ValidityDateRendering validityDateRendering
+	) {
+		return switch (validityDateRendering) {
+			case AGGREGATED -> dialect.aggregateDateRanges(dateRange.getStart(), dateRange.getEnd());
+			case INDIVIDUAL -> dialect.renderDateRange(dateRange.getStart(), dateRange.getEnd());
+		};
+	}
+
+	/** Physical representation required for validity dates in the projection. */
+	public enum ValidityDateRendering {
+		AGGREGATED,
+		INDIVIDUAL
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/rendering/package-info.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/rendering/package-info.java
new file mode 100644
index 0000000000..ea0369673d
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/compiler/rendering/package-info.java
@@ -0,0 +1,7 @@
+/**
+ * Internal services that render compiler IR into database-specific SQL expressions.
+ *
+ * <p>Backend references are temporary while the remaining legacy compiler transformations move into the SQL
+ * connector.</p>
+ */
+package com.bakdata.conquery.sql.compiler.rendering;
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/ResolvedQuery.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/ResolvedQuery.java
new file mode 100644
index 0000000000..e4db885fcd
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/ResolvedQuery.java
@@ -0,0 +1,36 @@
+package com.bakdata.conquery.sql.model;
+
+import java.util.List;
+
+import com.bakdata.conquery.sql.model.internal.ModelNormalization;
+import com.bakdata.conquery.sql.model.node.QueryNode;
+import com.bakdata.conquery.sql.model.result.ResultColumn;
+import com.bakdata.conquery.sql.model.schema.EntitySchema;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.AssertTrue;
+import jakarta.validation.constraints.NotNull;
+
+/**
+ * Complete input for compiling a concept query to SQL.
+ *
+ * @param includeValidityDate whether the final result exposes an aggregated validity-date column
+ */
+public record ResolvedQuery(
+		@NotNull @Valid EntitySchema entitySchema,
+		@NotNull @Valid QueryNode root,
+		boolean includeValidityDate,
+		@NotNull List<@NotNull @Valid ResultColumn> resultColumns
+) {
+
+	public ResolvedQuery {
+		resultColumns = ModelNormalization.immutableCopy(resultColumns);
+	}
+
+	@AssertTrue(message = "result column outputIds must be unique")
+	public boolean isResultColumnOutputIdsUnique() {
+		return resultColumns == null || resultColumns.stream()
+				.map(ResultColumn::outputId)
+				.distinct()
+				.count() == resultColumns.size();
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/internal/ModelNormalization.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/internal/ModelNormalization.java
new file mode 100644
index 0000000000..1f311ab6e8
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/internal/ModelNormalization.java
@@ -0,0 +1,27 @@
+package com.bakdata.conquery.sql.model.internal;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public final class ModelNormalization {
+
+	private ModelNormalization() {
+	}
+
+	public static <T> List<T> immutableCopy(List<T> values) {
+		return values == null ? null : Collections.unmodifiableList(new ArrayList<>(values));
+	}
+
+	public static <T> Set<T> immutableCopy(Set<T> values) {
+		return values == null ? null : Collections.unmodifiableSet(new LinkedHashSet<>(values));
+	}
+
+	public static <K, V> Map<K, V> immutableCopy(Map<K, V> values) {
+		return values == null ? null : Collections.unmodifiableMap(new LinkedHashMap<>(values));
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/AndNode.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/AndNode.java
new file mode 100644
index 0000000000..9e0de0c8dc
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/AndNode.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.sql.model.node;
+
+import java.util.List;
+
+import com.bakdata.conquery.sql.model.internal.ModelNormalization;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+
+/** Logical conjunction with its already-derived validity-date behavior. */
+public record AndNode(
+		@NotEmpty List<@NotNull @Valid QueryNode> children,
+		@NotNull DateAggregationAction dateAction,
+		boolean createExists
+) implements QueryNode {
+
+	public AndNode {
+		children = ModelNormalization.immutableCopy(children);
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/ConceptNode.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/ConceptNode.java
new file mode 100644
index 0000000000..9985c95874
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/ConceptNode.java
@@ -0,0 +1,25 @@
+package com.bakdata.conquery.sql.model.node;
+
+import java.util.List;
+
+import com.bakdata.conquery.sql.model.internal.ModelNormalization;
+import com.bakdata.conquery.sql.model.operation.ResolvedSelect;
+import com.bakdata.conquery.sql.model.schema.ResolvedConnector;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+
+/** A concept selection whose connectors, conditions, filters, and selects are fully resolved. */
+public record ConceptNode(
+		@NotBlank String logicalId,
+		@NotEmpty List<@NotNull @Valid ResolvedConnector> connectors,
+		@NotNull List<@NotNull @Valid ResolvedSelect> selects,
+		@NotNull DateAggregationAction dateAction
+) implements QueryNode {
+
+	public ConceptNode {
+		connectors = ModelNormalization.immutableCopy(connectors);
+		selects = ModelNormalization.immutableCopy(selects);
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/DateAggregationAction.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/DateAggregationAction.java
new file mode 100644
index 0000000000..688608c2de
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/DateAggregationAction.java
@@ -0,0 +1,9 @@
+package com.bakdata.conquery.sql.model.node;
+
+/** Defines how validity dates produced by child nodes are propagated. */
+public enum DateAggregationAction {
+	BLOCK,
+	MERGE,
+	INTERSECT,
+	NEGATE
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/DateRestrictionNode.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/DateRestrictionNode.java
new file mode 100644
index 0000000000..168a574652
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/DateRestrictionNode.java
@@ -0,0 +1,12 @@
+package com.bakdata.conquery.sql.model.node;
+
+import com.bakdata.conquery.sql.model.range.DateRange;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
+
+/** Applies an inclusive date restriction to its child. */
+public record DateRestrictionNode(
+		@NotNull @Valid DateRange dateRange,
+		@NotNull @Valid QueryNode child
+) implements QueryNode {
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/NegationNode.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/NegationNode.java
new file mode 100644
index 0000000000..27538a6d3f
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/NegationNode.java
@@ -0,0 +1,8 @@
+package com.bakdata.conquery.sql.model.node;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
+
+/** Logical negation. */
+public record NegationNode(@NotNull @Valid QueryNode child) implements QueryNode {
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/OrNode.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/OrNode.java
new file mode 100644
index 0000000000..9f0c98e74e
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/OrNode.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.sql.model.node;
+
+import java.util.List;
+
+import com.bakdata.conquery.sql.model.internal.ModelNormalization;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+
+/** Logical disjunction with its already-derived validity-date behavior. */
+public record OrNode(
+		@NotEmpty List<@NotNull @Valid QueryNode> children,
+		@NotNull DateAggregationAction dateAction,
+		boolean createExists
+) implements QueryNode {
+
+	public OrNode {
+		children = ModelNormalization.immutableCopy(children);
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/QueryNode.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/QueryNode.java
new file mode 100644
index 0000000000..8aa8152bb0
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/QueryNode.java
@@ -0,0 +1,5 @@
+package com.bakdata.conquery.sql.model.node;
+
+/** A normalized query-tree node accepted by SQL compilation. */
+public sealed interface QueryNode permits AndNode, OrNode, NegationNode, DateRestrictionNode, ConceptNode {
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/package-info.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/package-info.java
new file mode 100644
index 0000000000..b24d1e8cca
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/node/package-info.java
@@ -0,0 +1,2 @@
+/** Normalized nodes of a fully resolved query tree. */
+package com.bakdata.conquery.sql.model.node;
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/BuiltInAggregations.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/BuiltInAggregations.java
new file mode 100644
index 0000000000..849378f558
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/BuiltInAggregations.java
@@ -0,0 +1,132 @@
+package com.bakdata.conquery.sql.model.operation;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.sql.model.internal.ModelNormalization;
+import com.bakdata.conquery.sql.model.schema.DateColumns;
+import com.bakdata.conquery.sql.model.schema.ResolvedColumn;
+import com.bakdata.conquery.sql.validation.AllowedColumnTypes;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.AssertTrue;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+
+/** Framework-neutral aggregation operations supported by the SQL connector. */
+public final class BuiltInAggregations {
+
+	private BuiltInAggregations() {
+	}
+
+	public record Count(
+			@NotNull @Valid ResolvedColumn column,
+			@NotNull List<@NotNull @Valid ResolvedColumn> distinctBy
+	) implements ResolvedAggregation {
+
+		public Count {
+			distinctBy = ModelNormalization.immutableCopy(distinctBy);
+		}
+
+		@AssertTrue(message = "count columns must belong to the same table")
+		public boolean isOnSameTable() {
+			return sameTable(withColumn(column, distinctBy));
+		}
+	}
+
+	public record CountQuarters(@NotNull @Valid DateColumns dates) implements ResolvedAggregation {
+	}
+
+	public record DurationSum(
+			@NotNull @Valid DateColumns dates,
+			@NotNull List<@NotNull @Valid ResolvedColumn> distinctBy
+	) implements ResolvedAggregation {
+
+		public DurationSum {
+			distinctBy = ModelNormalization.immutableCopy(distinctBy);
+		}
+
+		@AssertTrue(message = "duration-sum columns must belong to the same table")
+		public boolean isOnSameTable() {
+			return dates == null || sameTable(withColumns(dates.columns(), distinctBy));
+		}
+	}
+
+	public record Sum(
+			@NotNull @Valid @AllowedColumnTypes({ColumnType.INTEGER, ColumnType.REAL, ColumnType.DECIMAL, ColumnType.MONEY})
+			ResolvedColumn column,
+			@NotNull Optional<@Valid @AllowedColumnTypes({
+					ColumnType.INTEGER, ColumnType.REAL, ColumnType.DECIMAL, ColumnType.MONEY
+			}) ResolvedColumn> subtractColumn,
+			@NotNull List<@NotNull @Valid ResolvedColumn> distinctBy
+	) implements ResolvedAggregation {
+
+		public Sum {
+			distinctBy = ModelNormalization.immutableCopy(distinctBy);
+		}
+
+		@AssertTrue(message = "column and subtractColumn must have the same type")
+		public boolean isMatchingColumnType() {
+			return column == null || subtractColumn == null || subtractColumn.isEmpty()
+					|| column.type() == subtractColumn.get().type();
+		}
+
+		@AssertTrue(message = "sum columns must belong to the same table")
+		public boolean isOnSameTable() {
+			if (subtractColumn == null) {
+				return true;
+			}
+			List<ResolvedColumn> columns = withColumn(column, distinctBy);
+			subtractColumn.ifPresent(columns::add);
+			return sameTable(columns);
+		}
+	}
+
+	public record Flags(
+			@NotEmpty Map<@NotBlank String, @NotNull @Valid @AllowedColumnTypes(ColumnType.BOOLEAN) ResolvedColumn> columns
+	) implements ResolvedAggregation {
+
+		public Flags {
+			columns = ModelNormalization.immutableCopy(columns);
+		}
+
+		@AssertTrue(message = "flag columns must be unique")
+		public boolean isUnique() {
+			return columns == null || columns.values().stream().distinct().count() == columns.size();
+		}
+
+		@AssertTrue(message = "flag columns must belong to the same table")
+		public boolean isOnSameTable() {
+			return columns == null || sameTable(columns.values());
+		}
+	}
+
+	private static List<ResolvedColumn> withColumn(ResolvedColumn column, List<ResolvedColumn> other) {
+		List<ResolvedColumn> columns = new ArrayList<>();
+		if (column != null) {
+			columns.add(column);
+		}
+		return withColumns(columns, other);
+	}
+
+	private static List<ResolvedColumn> withColumns(List<ResolvedColumn> columns, List<ResolvedColumn> other) {
+		List<ResolvedColumn> combined = new ArrayList<>(columns);
+		if (other != null) {
+			combined.addAll(other);
+		}
+		return combined;
+	}
+
+	private static boolean sameTable(Collection<ResolvedColumn> columns) {
+		return columns.stream()
+				.filter(java.util.Objects::nonNull)
+				.map(ResolvedColumn::table)
+				.distinct()
+				.limit(2)
+				.count() < 2;
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/BuiltInConditions.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/BuiltInConditions.java
new file mode 100644
index 0000000000..af4e34591b
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/BuiltInConditions.java
@@ -0,0 +1,69 @@
+package com.bakdata.conquery.sql.model.operation;
+
+import java.util.List;
+import java.util.Set;
+
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.sql.model.internal.ModelNormalization;
+import com.bakdata.conquery.sql.model.schema.ResolvedColumn;
+import com.bakdata.conquery.sql.validation.AllowedColumnTypes;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.AssertTrue;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+
+/** Declarative connector and concept-element conditions supported by the SQL connector. */
+public final class BuiltInConditions {
+
+	private BuiltInConditions() {
+	}
+
+	public record AllOf(
+			@NotEmpty List<@NotNull @Valid ResolvedCondition> conditions
+	) implements ResolvedCondition {
+
+		public AllOf {
+			conditions = ModelNormalization.immutableCopy(conditions);
+		}
+	}
+
+	public record Not(@NotNull @Valid ResolvedCondition condition) implements ResolvedCondition {
+	}
+
+	public record StringValues(
+			@NotNull @Valid @AllowedColumnTypes(ColumnType.STRING) ResolvedColumn column,
+			@NotEmpty Set<@NotNull String> values
+	) implements ResolvedCondition {
+
+		public StringValues {
+			values = ModelNormalization.immutableCopy(values);
+		}
+	}
+
+	public record Presence(@NotNull @Valid ResolvedColumn column, boolean present) implements ResolvedCondition {
+	}
+
+	public record Prefixes(
+			@NotNull @Valid @AllowedColumnTypes(ColumnType.STRING) ResolvedColumn column,
+			@NotEmpty List<@NotBlank String> prefixes
+	) implements ResolvedCondition {
+
+		public Prefixes {
+			prefixes = ModelNormalization.immutableCopy(prefixes);
+		}
+	}
+
+	public record PrefixRange(
+			@NotNull @Valid @AllowedColumnTypes(ColumnType.STRING) ResolvedColumn column,
+			@NotBlank String minimum,
+			@NotBlank String maximum
+	) implements ResolvedCondition {
+
+		@AssertTrue(message = "prefix bounds must have equal length and be ordered")
+		public boolean isOrdered() {
+			return minimum == null || maximum == null
+					|| minimum.length() == maximum.length() && minimum.compareTo(maximum) <= 0;
+		}
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/BuiltInFilters.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/BuiltInFilters.java
new file mode 100644
index 0000000000..6c4a3c6cea
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/BuiltInFilters.java
@@ -0,0 +1,81 @@
+package com.bakdata.conquery.sql.model.operation;
+
+import java.time.LocalDate;
+import java.time.temporal.ChronoUnit;
+import java.util.Optional;
+import java.util.Set;
+
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.sql.model.internal.ModelNormalization;
+import com.bakdata.conquery.sql.model.range.NumberRange;
+import com.bakdata.conquery.sql.model.range.SubstringRange;
+import com.bakdata.conquery.sql.model.schema.ResolvedColumn;
+import com.bakdata.conquery.sql.validation.AllowedColumnTypes;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.AssertTrue;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+
+/** Framework-neutral filter operations supported by the SQL connector. */
+public final class BuiltInFilters {
+
+	private BuiltInFilters() {
+	}
+
+	public record StringValues(
+			@NotNull @Valid @AllowedColumnTypes(ColumnType.STRING) ResolvedColumn column,
+			@NotEmpty Set<@NotNull String> values,
+			@NotNull Optional<@Valid SubstringRange> substring
+	) implements ResolvedFilter {
+
+		public StringValues {
+			values = ModelNormalization.immutableCopy(values);
+		}
+
+		public StringValues(ResolvedColumn column, Set<String> values) {
+			this(column, values, Optional.empty());
+		}
+	}
+
+	public record NumericColumnRange(
+			@NotNull @Valid @AllowedColumnTypes({ColumnType.INTEGER, ColumnType.REAL, ColumnType.DECIMAL, ColumnType.MONEY})
+			ResolvedColumn column,
+			@NotNull @Valid NumberRange range
+	) implements ResolvedFilter {
+	}
+
+	public record AggregationRange(
+			@NotNull @Valid ResolvedAggregation aggregation,
+			@NotNull @Valid NumberRange range
+	) implements ResolvedFilter {
+	}
+
+	/** Filters by distance to an end date that was frozen while resolving the query. */
+	public record DateDistanceRange(
+			@NotNull @Valid @AllowedColumnTypes(ColumnType.DATE) ResolvedColumn column,
+			@NotNull ChronoUnit unit,
+			@NotNull LocalDate endDate,
+			@NotNull @Valid NumberRange range
+	) implements ResolvedFilter {
+	}
+
+	public record Flags(
+			@NotNull @Valid BuiltInAggregations.Flags availableFlags,
+			@NotEmpty Set<@NotNull String> selectedFlags
+	) implements ResolvedFilter {
+
+		public Flags {
+			selectedFlags = ModelNormalization.immutableCopy(selectedFlags);
+		}
+
+		public Flags(java.util.Map<String, ResolvedColumn> availableFlags, Set<String> selectedFlags) {
+			this(new BuiltInAggregations.Flags(availableFlags), selectedFlags);
+		}
+
+		@AssertTrue(message = "selectedFlags must be defined by availableFlags")
+		public boolean isSelectionKnown() {
+			return availableFlags == null || availableFlags.columns() == null || selectedFlags == null
+					|| availableFlags.columns().keySet().containsAll(selectedFlags);
+		}
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/BuiltInSelects.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/BuiltInSelects.java
new file mode 100644
index 0000000000..6bf44ff043
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/BuiltInSelects.java
@@ -0,0 +1,76 @@
+package com.bakdata.conquery.sql.model.operation;
+
+import java.time.LocalDate;
+import java.time.temporal.ChronoUnit;
+import java.util.List;
+import java.util.Optional;
+
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.sql.model.internal.ModelNormalization;
+import com.bakdata.conquery.sql.model.range.SubstringRange;
+import com.bakdata.conquery.sql.model.schema.DateColumns;
+import com.bakdata.conquery.sql.model.schema.ResolvedColumn;
+import com.bakdata.conquery.sql.validation.AllowedColumnTypes;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.AssertTrue;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+
+/** Framework-neutral select operations supported by the SQL connector. */
+public final class BuiltInSelects {
+
+	private BuiltInSelects() {
+	}
+
+	public enum ValueOperation {
+		DISTINCT,
+		FIRST,
+		LAST,
+		RANDOM
+	}
+
+	public record Aggregation(@NotNull @Valid ResolvedAggregation aggregation) implements ResolvedSelect {
+	}
+
+	public record Values(
+			@NotNull @Valid ResolvedColumn column,
+			@NotNull ValueOperation operation,
+			@NotNull Optional<@Valid SubstringRange> substring
+	) implements ResolvedSelect {
+
+		@AssertTrue(message = "substring requires a STRING column")
+		public boolean isSubstringOnStringColumn() {
+			return column == null || substring == null || substring.isEmpty() || column.type() == ColumnType.STRING;
+		}
+	}
+
+	public record DateUnion(@NotNull @Valid DateColumns dates) implements ResolvedSelect {
+	}
+
+	/** Selects the distance to an end date that was frozen while resolving the query. */
+	public record DateDistance(
+			@NotNull @Valid @AllowedColumnTypes({ColumnType.DATE, ColumnType.DATE_RANGE}) ResolvedColumn column,
+			@NotNull ChronoUnit unit,
+			@NotNull LocalDate endDate
+	) implements ResolvedSelect {
+	}
+
+	/** Aggregates the resolved concept-value columns across connector tables. */
+	public record ConceptValues(
+			@NotEmpty List<@NotNull @Valid ResolvedColumn> columns
+	) implements ResolvedSelect {
+
+		public ConceptValues {
+			columns = ModelNormalization.immutableCopy(columns);
+		}
+	}
+
+	public record EventDateUnion() implements ResolvedSelect {
+	}
+
+	public record EventDurationSum() implements ResolvedSelect {
+	}
+
+	public record Exists() implements ResolvedSelect {
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/ResolvedAggregation.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/ResolvedAggregation.java
new file mode 100644
index 0000000000..ca477dcd11
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/ResolvedAggregation.java
@@ -0,0 +1,5 @@
+package com.bakdata.conquery.sql.model.operation;
+
+/** A resolved aggregation that can be exposed as a result or constrained by an aggregation filter. */
+public interface ResolvedAggregation {
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/ResolvedCondition.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/ResolvedCondition.java
new file mode 100644
index 0000000000..8662889588
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/ResolvedCondition.java
@@ -0,0 +1,5 @@
+package com.bakdata.conquery.sql.model.operation;
+
+/** A resolved connector or concept-element condition. */
+public interface ResolvedCondition {
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/ResolvedFilter.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/ResolvedFilter.java
new file mode 100644
index 0000000000..8b42def1ff
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/ResolvedFilter.java
@@ -0,0 +1,10 @@
+package com.bakdata.conquery.sql.model.operation;
+
+/**
+ * Marker for an immutable, validated filter operation.
+ *
+ * <p>Implementations may be supplied by extensions. They must contain resolved columns and typed values rather than
+ * repository identifiers.</p>
+ */
+public interface ResolvedFilter {
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/ResolvedSelect.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/ResolvedSelect.java
new file mode 100644
index 0000000000..20ff85d949
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/ResolvedSelect.java
@@ -0,0 +1,9 @@
+package com.bakdata.conquery.sql.model.operation;
+
+/**
+ * Marker for an immutable, validated select operation.
+ *
+ * <p>Implementations may be supplied by extensions and are dispatched to matching SQL converters.</p>
+ */
+public interface ResolvedSelect {
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/package-info.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/package-info.java
new file mode 100644
index 0000000000..a2b0015f72
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/operation/package-info.java
@@ -0,0 +1,2 @@
+/** Extensible filter, select, condition, and aggregation operations accepted by SQL compilation. */
+package com.bakdata.conquery.sql.model.operation;
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/package-info.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/package-info.java
new file mode 100644
index 0000000000..247a51dd68
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/package-info.java
@@ -0,0 +1,12 @@
+/**
+ * Framework-neutral, fully resolved input model for SQL query compilation.
+ *
+ * <p>Instances in this package must not require repository access or identifier resolution during compilation. They
+ * describe query semantics and physical database objects, but deliberately exclude dataset routing, datasource
+ * selection, connections, dialects, and SQL compiler state.</p>
+ *
+ * <p>The root query aggregate is complemented by dedicated packages for query nodes, operations, ranges, result
+ * metadata, and physical schema references. Validation and SQL business logic live in sibling packages so this package
+ * remains the connector's immutable input boundary.</p>
+ */
+package com.bakdata.conquery.sql.model;
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/range/DateRange.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/range/DateRange.java
new file mode 100644
index 0000000000..5df5120293
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/range/DateRange.java
@@ -0,0 +1,25 @@
+package com.bakdata.conquery.sql.model.range;
+
+import java.time.LocalDate;
+import java.util.Optional;
+
+import jakarta.validation.constraints.AssertTrue;
+import jakarta.validation.constraints.NotNull;
+
+/** Inclusive date restriction. An empty bound represents an unbounded side. */
+public record DateRange(
+		@NotNull Optional<LocalDate> startInclusive,
+		@NotNull Optional<LocalDate> endInclusive
+) {
+
+	@AssertTrue(message = "startInclusive must not be after endInclusive")
+	public boolean isOrdered() {
+		return startInclusive == null || endInclusive == null
+				|| startInclusive.isEmpty() || endInclusive.isEmpty()
+				|| !startInclusive.get().isAfter(endInclusive.get());
+	}
+
+	public static DateRange closed(LocalDate startInclusive, LocalDate endInclusive) {
+		return new DateRange(Optional.of(startInclusive), Optional.of(endInclusive));
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/range/NumberRange.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/range/NumberRange.java
new file mode 100644
index 0000000000..040be4dd72
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/range/NumberRange.java
@@ -0,0 +1,43 @@
+package com.bakdata.conquery.sql.model.range;
+
+import java.math.BigDecimal;
+import java.util.Objects;
+import java.util.Optional;
+
+import jakarta.validation.constraints.AssertTrue;
+import jakarta.validation.constraints.NotNull;
+
+/** Inclusive numeric range. An empty bound represents an unbounded side. */
+public record NumberRange(
+		@NotNull Optional<BigDecimal> minimum,
+		@NotNull Optional<BigDecimal> maximum
+) {
+
+	@AssertTrue(message = "minimum must not be greater than maximum")
+	public boolean isOrdered() {
+		return minimum == null || maximum == null
+				|| minimum.isEmpty() || maximum.isEmpty()
+				|| minimum.get().compareTo(maximum.get()) <= 0;
+	}
+
+	public static NumberRange closed(Number minimum, Number maximum) {
+		return new NumberRange(Optional.of(decimal(minimum)), Optional.of(decimal(maximum)));
+	}
+
+	public static NumberRange atLeast(Number minimum) {
+		return new NumberRange(Optional.of(decimal(minimum)), Optional.empty());
+	}
+
+	public static NumberRange atMost(Number maximum) {
+		return new NumberRange(Optional.empty(), Optional.of(decimal(maximum)));
+	}
+
+	public static NumberRange unbounded() {
+		return new NumberRange(Optional.empty(), Optional.empty());
+	}
+
+	private static BigDecimal decimal(Number value) {
+		Objects.requireNonNull(value, "value");
+		return value instanceof BigDecimal decimal ? decimal : new BigDecimal(value.toString());
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/range/SubstringRange.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/range/SubstringRange.java
new file mode 100644
index 0000000000..f087350e41
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/range/SubstringRange.java
@@ -0,0 +1,27 @@
+package com.bakdata.conquery.sql.model.range;
+
+import java.util.Optional;
+
+import jakarta.validation.constraints.AssertTrue;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.PositiveOrZero;
+
+/** Zero-based substring bounds with an exclusive, optionally unbounded end. */
+public record SubstringRange(
+		@PositiveOrZero int startInclusive,
+		@NotNull Optional<@PositiveOrZero Integer> endExclusive
+) {
+
+	@AssertTrue(message = "endExclusive must not be smaller than startInclusive")
+	public boolean isOrdered() {
+		return endExclusive == null || endExclusive.isEmpty() || endExclusive.get() >= startInclusive;
+	}
+
+	public static SubstringRange from(int startInclusive) {
+		return new SubstringRange(startInclusive, Optional.empty());
+	}
+
+	public static SubstringRange between(int startInclusive, int endExclusive) {
+		return new SubstringRange(startInclusive, Optional.of(endExclusive));
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/range/package-info.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/range/package-info.java
new file mode 100644
index 0000000000..778528444f
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/range/package-info.java
@@ -0,0 +1,2 @@
+/** Typed, framework-neutral range values used by resolved nodes and operations. */
+package com.bakdata.conquery.sql.model.range;
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/result/ResultColumn.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/result/ResultColumn.java
new file mode 100644
index 0000000000..f2af05a985
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/result/ResultColumn.java
@@ -0,0 +1,17 @@
+package com.bakdata.conquery.sql.model.result;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+
+/**
+ * Backend-independent identity and logical type of a requested result column.
+ *
+ * <p>Labels, descriptions, semantics, and formatting instructions are deliberately excluded. Backends retain that
+ * presentation metadata and correlate it with compiled columns through {@link #outputId()}.</p>
+ */
+public record ResultColumn(
+		@NotBlank String outputId,
+		@NotNull @Valid ResultType type
+) {
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/result/ResultType.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/result/ResultType.java
new file mode 100644
index 0000000000..56f10b365d
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/result/ResultType.java
@@ -0,0 +1,20 @@
+package com.bakdata.conquery.sql.model.result;
+
+import jakarta.validation.constraints.NotNull;
+
+/** Logical type of a result column. */
+public sealed interface ResultType permits ResultType.Primitive, ResultType.ListType {
+
+	enum Primitive implements ResultType {
+		BOOLEAN,
+		INTEGER,
+		NUMERIC,
+		DATE,
+		DATE_RANGE,
+		STRING,
+		MONEY
+	}
+
+	record ListType(@NotNull Primitive elementType) implements ResultType {
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/result/package-info.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/result/package-info.java
new file mode 100644
index 0000000000..32eca5222f
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/result/package-info.java
@@ -0,0 +1,2 @@
+/** Backend-independent identities and logical types of requested result columns. */
+package com.bakdata.conquery.sql.model.result;
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/DateColumns.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/DateColumns.java
new file mode 100644
index 0000000000..1c6fa99a0d
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/DateColumns.java
@@ -0,0 +1,42 @@
+package com.bakdata.conquery.sql.model.schema;
+
+import java.util.List;
+import java.util.Objects;
+
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.sql.validation.AllowedColumnTypes;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.AssertTrue;
+import jakarta.validation.constraints.NotNull;
+
+/** Resolved physical representation of a date or date range used by an operation. */
+public sealed interface DateColumns permits DateColumns.Single, DateColumns.Pair {
+
+	List<ResolvedColumn> columns();
+
+	record Single(
+			@NotNull @Valid @AllowedColumnTypes({ColumnType.DATE, ColumnType.DATE_RANGE}) ResolvedColumn column
+	) implements DateColumns {
+
+		@Override
+		public List<ResolvedColumn> columns() {
+			return column == null ? List.of() : List.of(column);
+		}
+	}
+
+	record Pair(
+			@NotNull @Valid @AllowedColumnTypes(ColumnType.DATE) ResolvedColumn start,
+			@NotNull @Valid @AllowedColumnTypes(ColumnType.DATE) ResolvedColumn end
+	) implements DateColumns {
+
+		@Override
+		public List<ResolvedColumn> columns() {
+			return start == null || end == null ? List.of() : List.of(start, end);
+		}
+
+		@AssertTrue(message = "date columns must belong to the same table")
+		public boolean isOnSameTable() {
+			return start == null || end == null || Objects.equals(start.table(), end.table());
+		}
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/EntitySchema.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/EntitySchema.java
new file mode 100644
index 0000000000..4b0d51e4b6
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/EntitySchema.java
@@ -0,0 +1,17 @@
+package com.bakdata.conquery.sql.model.schema;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.AssertTrue;
+import jakarta.validation.constraints.NotNull;
+
+/** Physical source used to enumerate all entities, for example when compiling a root-level negation. */
+public record EntitySchema(
+		@NotNull @Valid SqlTable table,
+		@NotNull @Valid ResolvedColumn primaryId
+) {
+
+	@AssertTrue(message = "primaryId must belong to the entity table")
+	public boolean isPrimaryIdOnEntityTable() {
+		return table == null || primaryId == null || table.equals(primaryId.table());
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/ResolvedColumn.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/ResolvedColumn.java
new file mode 100644
index 0000000000..560a9a0d70
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/ResolvedColumn.java
@@ -0,0 +1,16 @@
+package com.bakdata.conquery.sql.model.schema;
+
+import com.bakdata.conquery.models.datasets.ColumnType;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+
+/** A column whose owning table, physical name, and logical type are known. */
+public record ResolvedColumn(
+		@NotBlank String logicalId,
+		@NotNull @Valid SqlTable table,
+		@NotBlank String physicalName,
+		@NotNull ColumnType type,
+		boolean nullable
+) {
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/ResolvedConnector.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/ResolvedConnector.java
new file mode 100644
index 0000000000..4201426902
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/ResolvedConnector.java
@@ -0,0 +1,59 @@
+package com.bakdata.conquery.sql.model.schema;
+
+import java.util.List;
+import java.util.Optional;
+
+import com.bakdata.conquery.sql.model.internal.ModelNormalization;
+import com.bakdata.conquery.sql.model.operation.ResolvedCondition;
+import com.bakdata.conquery.sql.model.operation.ResolvedFilter;
+import com.bakdata.conquery.sql.model.operation.ResolvedSelect;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.AssertTrue;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+
+/** A selected connector with all physical columns and operations resolved. */
+public record ResolvedConnector(
+		@NotBlank String logicalId,
+		@NotNull @Valid SqlTable table,
+		@NotNull @Valid ResolvedColumn primaryId,
+		@NotNull Optional<@Valid ResolvedColumn> secondaryId,
+		@NotNull @Valid ResolvedValidityDate validityDate,
+		@NotNull List<@NotNull @Valid ResolvedFilter> filters,
+		@NotNull List<@NotNull @Valid ResolvedSelect> selects,
+		@NotNull List<@NotNull @Valid ResolvedCondition> conditions
+) {
+
+	public ResolvedConnector {
+		filters = ModelNormalization.immutableCopy(filters);
+		selects = ModelNormalization.immutableCopy(selects);
+		conditions = ModelNormalization.immutableCopy(conditions);
+	}
+
+	@AssertTrue(message = "identifier columns must belong to the connector table")
+	public boolean isIdentifierColumnsOnConnectorTable() {
+		return table == null
+				|| primaryId == null
+				|| secondaryId == null
+				|| table.equals(primaryId.table()) && secondaryId.stream().map(ResolvedColumn::table).allMatch(table::equals);
+	}
+
+	@AssertTrue(message = "validity-date columns must belong to the connector table")
+	public boolean isValidityDateOnConnectorTable() {
+		if (validityDate == null || table == null) {
+			return true;
+		}
+		switch (validityDate) {
+			case ResolvedValidityDate.None ignored -> {
+				return true;
+			}
+			case ResolvedValidityDate.Point point -> {
+				return point.column() == null || table.equals(point.column().table());
+			}
+			case ResolvedValidityDate.Range range -> {
+				return range.start() == null || range.end() == null
+						|| table.equals(range.start().table()) && table.equals(range.end().table());
+			}
+		}
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/ResolvedValidityDate.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/ResolvedValidityDate.java
new file mode 100644
index 0000000000..2fc8a30041
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/ResolvedValidityDate.java
@@ -0,0 +1,32 @@
+package com.bakdata.conquery.sql.model.schema;
+
+import java.util.Objects;
+
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.sql.validation.AllowedColumnTypes;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.AssertTrue;
+import jakarta.validation.constraints.NotNull;
+
+/** Physical representation of event validity for a connector. */
+public sealed interface ResolvedValidityDate permits ResolvedValidityDate.None, ResolvedValidityDate.Point, ResolvedValidityDate.Range {
+
+	record None() implements ResolvedValidityDate {
+	}
+
+	record Point(
+			@NotNull @Valid @AllowedColumnTypes(ColumnType.DATE) ResolvedColumn column
+	) implements ResolvedValidityDate {
+	}
+
+	record Range(
+			@NotNull @Valid @AllowedColumnTypes(ColumnType.DATE) ResolvedColumn start,
+			@NotNull @Valid @AllowedColumnTypes(ColumnType.DATE) ResolvedColumn end
+	) implements ResolvedValidityDate {
+
+		@AssertTrue(message = "validity-date columns must belong to the same table")
+		public boolean isOnSameTable() {
+			return start == null || end == null || Objects.equals(start.table(), end.table());
+		}
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/SqlTable.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/SqlTable.java
new file mode 100644
index 0000000000..16e59d6b4d
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/SqlTable.java
@@ -0,0 +1,26 @@
+package com.bakdata.conquery.sql.model.schema;
+
+import java.util.Arrays;
+import java.util.List;
+
+import com.bakdata.conquery.sql.model.internal.ModelNormalization;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotEmpty;
+
+/** A logical table together with its unquoted physical SQL name. */
+public record SqlTable(
+		@NotBlank String logicalId,
+		@NotEmpty List<@NotBlank String> physicalName
+) {
+
+	public SqlTable {
+		physicalName = ModelNormalization.immutableCopy(physicalName);
+	}
+
+	public static SqlTable of(String logicalId, String... physicalName) {
+		if (physicalName == null) {
+			return new SqlTable(logicalId, null);
+		}
+		return new SqlTable(logicalId, Arrays.asList(physicalName));
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/package-info.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/package-info.java
new file mode 100644
index 0000000000..79d98246e4
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/model/schema/package-info.java
@@ -0,0 +1,2 @@
+/** Resolved physical tables, columns, connectors, and entity schema used during SQL compilation. */
+package com.bakdata.conquery.sql.model.schema;
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/package-info.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/package-info.java
new file mode 100644
index 0000000000..f3fb3af679
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/package-info.java
@@ -0,0 +1,8 @@
+/**
+ * Framework-neutral SQL connector contracts and services.
+ *
+ * <p>{@code model} defines the fully resolved input, {@code validation} verifies that input, and {@code compiler}
+ * defines framework-neutral compilation contracts. Conversion and execution implementations may depend on these
+ * contracts; model code must not depend on compiler or execution services.</p>
+ */
+package com.bakdata.conquery.sql;
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/validation/AllowedColumnTypes.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/validation/AllowedColumnTypes.java
new file mode 100644
index 0000000000..f5a9c004d0
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/validation/AllowedColumnTypes.java
@@ -0,0 +1,26 @@
+package com.bakdata.conquery.sql.validation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import com.bakdata.conquery.models.datasets.ColumnType;
+import jakarta.validation.Constraint;
+import jakarta.validation.Payload;
+
+@Documented
+@Constraint(validatedBy = AllowedColumnTypesValidator.class)
+@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE_USE, ElementType.RECORD_COMPONENT})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AllowedColumnTypes {
+
+	String message() default "column type is not supported";
+
+	Class<?>[] groups() default {};
+
+	Class<? extends Payload>[] payload() default {};
+
+	ColumnType[] value();
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/validation/AllowedColumnTypesValidator.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/validation/AllowedColumnTypesValidator.java
new file mode 100644
index 0000000000..6b1c9524f1
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/validation/AllowedColumnTypesValidator.java
@@ -0,0 +1,23 @@
+package com.bakdata.conquery.sql.validation;
+
+import java.util.EnumSet;
+
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.sql.model.schema.ResolvedColumn;
+import jakarta.validation.ConstraintValidator;
+import jakarta.validation.ConstraintValidatorContext;
+
+public final class AllowedColumnTypesValidator implements ConstraintValidator<AllowedColumnTypes, ResolvedColumn> {
+
+	private EnumSet<ColumnType> allowedTypes;
+
+	@Override
+	public void initialize(AllowedColumnTypes constraint) {
+		allowedTypes = EnumSet.copyOf(java.util.List.of(constraint.value()));
+	}
+
+	@Override
+	public boolean isValid(ResolvedColumn column, ConstraintValidatorContext context) {
+		return column == null || column.type() == null || allowedTypes.contains(column.type());
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/validation/ResolvedQueryValidation.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/validation/ResolvedQueryValidation.java
new file mode 100644
index 0000000000..2032de20cf
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/validation/ResolvedQueryValidation.java
@@ -0,0 +1,26 @@
+package com.bakdata.conquery.sql.validation;
+
+import java.util.Objects;
+import java.util.Set;
+
+import com.bakdata.conquery.sql.model.ResolvedQuery;
+import jakarta.validation.ConstraintViolation;
+import jakarta.validation.ConstraintViolationException;
+import jakarta.validation.Validator;
+
+/** Validates the complete resolved query graph before SQL compilation starts. */
+public final class ResolvedQueryValidation {
+
+	private final Validator validator;
+
+	public ResolvedQueryValidation(Validator validator) {
+		this.validator = Objects.requireNonNull(validator, "validator");
+	}
+
+	public void validate(ResolvedQuery query) {
+		Set<ConstraintViolation<ResolvedQuery>> violations = validator.validate(Objects.requireNonNull(query, "query"));
+		if (!violations.isEmpty()) {
+			throw new ConstraintViolationException(violations);
+		}
+	}
+}
diff --git a/sql-connector/src/main/java/com/bakdata/conquery/sql/validation/package-info.java b/sql-connector/src/main/java/com/bakdata/conquery/sql/validation/package-info.java
new file mode 100644
index 0000000000..c33adf3ff6
--- /dev/null
+++ b/sql-connector/src/main/java/com/bakdata/conquery/sql/validation/package-info.java
@@ -0,0 +1,6 @@
+/**
+ * Jakarta Bean Validation constraints and the validation boundary for resolved SQL models.
+ *
+ * <p>Validation reports violations but never resolves identifiers, supplies defaults, or mutates model instances.</p>
+ */
+package com.bakdata.conquery.sql.validation;
diff --git a/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/CompiledQueryTest.java b/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/CompiledQueryTest.java
new file mode 100644
index 0000000000..feaedaaf16
--- /dev/null
+++ b/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/CompiledQueryTest.java
@@ -0,0 +1,61 @@
+package com.bakdata.conquery.sql.compiler;
+
+import static com.bakdata.conquery.sql.model.ValidationTestSupport.assertInvalid;
+import static com.bakdata.conquery.sql.model.ValidationTestSupport.assertValid;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.bakdata.conquery.sql.model.result.ResultType;
+import org.junit.jupiter.api.Test;
+
+class CompiledQueryTest {
+
+	private static final CompiledColumn ENTITY_ID = new CompiledColumn(
+			"entity-id", "entity_id", ResultType.Primitive.STRING, ColumnRole.ENTITY_ID
+	);
+	private static final CompiledColumn RESULT = new CompiledColumn(
+			"concept.exists", "concept_exists", ResultType.Primitive.BOOLEAN, ColumnRole.RESULT
+	);
+
+	@Test
+	void shouldDescribeTheOrderedPhysicalResult() {
+		CompiledQuery query = new CompiledQuery("select entity_id, concept_exists from result", List.of(ENTITY_ID, RESULT));
+
+		assertValid(query);
+		assertEquals(List.of(ENTITY_ID, RESULT), query.columns());
+	}
+
+	@Test
+	void shouldDefensivelyCopyColumns() {
+		List<CompiledColumn> columns = new ArrayList<>(List.of(ENTITY_ID));
+		CompiledQuery query = new CompiledQuery("select entity_id from result", columns);
+
+		columns.clear();
+
+		assertEquals(List.of(ENTITY_ID), query.columns());
+		assertThrows(UnsupportedOperationException.class, () -> query.columns().clear());
+	}
+
+	@Test
+	void shouldRejectIncompleteOutputContracts() {
+		assertInvalid(new CompiledColumn("", "entity_id", ResultType.Primitive.STRING, ColumnRole.ENTITY_ID));
+		assertInvalid(new CompiledQuery("", List.of(ENTITY_ID)));
+		assertInvalid(new CompiledQuery("select 1", List.of()));
+	}
+
+	@Test
+	void shouldRejectAmbiguousColumnMappings() {
+		CompiledColumn duplicateOutputId = new CompiledColumn(
+				ENTITY_ID.outputId(), "other_id", ResultType.Primitive.STRING, ColumnRole.RESULT
+		);
+		CompiledColumn duplicateAlias = new CompiledColumn(
+				"other-id", ENTITY_ID.sqlAlias(), ResultType.Primitive.STRING, ColumnRole.RESULT
+		);
+
+		assertInvalid(new CompiledQuery("select entity_id, other_id from result", List.of(ENTITY_ID, duplicateOutputId)));
+		assertInvalid(new CompiledQuery("select entity_id, entity_id from result", List.of(ENTITY_ID, duplicateAlias)));
+	}
+}
diff --git a/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/ir/QualifyingUtilTest.java b/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/ir/QualifyingUtilTest.java
new file mode 100644
index 0000000000..02e8f5484e
--- /dev/null
+++ b/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/ir/QualifyingUtilTest.java
@@ -0,0 +1,31 @@
+package com.bakdata.conquery.sql.compiler.ir;
+
+import static org.jooq.impl.DSL.field;
+import static org.jooq.impl.DSL.name;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.List;
+
+import com.bakdata.conquery.sql.compiler.ir.select.ExtractingSqlSelect;
+import com.bakdata.conquery.sql.compiler.ir.select.SqlSelect;
+import org.junit.jupiter.api.Test;
+
+class QualifyingUtilTest {
+
+	@Test
+	void shouldQualifyFieldsWithoutChangingTheirType() {
+		var qualified = QualifyingUtil.qualify(field(name("result"), Integer.class), "query_step");
+
+		assertEquals(name("query_step", "result"), qualified.getQualifiedName());
+		assertEquals(Integer.class, qualified.getType());
+	}
+
+	@Test
+	void shouldQualifySelectLists() {
+		SqlSelect select = new ExtractingSqlSelect<>("source", "result", Integer.class);
+
+		List<SqlSelect> qualified = QualifyingUtil.qualify(List.of(select), "query_step");
+
+		assertEquals(name("query_step", "result"), qualified.getFirst().toFields().getFirst().getQualifiedName());
+	}
+}
diff --git a/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/ir/SelectsTest.java b/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/ir/SelectsTest.java
new file mode 100644
index 0000000000..3eb7e5d21a
--- /dev/null
+++ b/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/ir/SelectsTest.java
@@ -0,0 +1,68 @@
+package com.bakdata.conquery.sql.compiler.ir;
+
+import static org.jooq.impl.DSL.field;
+import static org.jooq.impl.DSL.name;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
+import java.sql.Date;
+import java.util.List;
+import java.util.Optional;
+import org.jooq.Field;
+import org.junit.jupiter.api.Test;
+
+class SelectsTest {
+
+	@Test
+	void shouldBuildImmutableSelectsWithDefaultDates() {
+		FieldWrapper<Integer> explicit = new FieldWrapper<>(field(name("value"), Integer.class));
+		Selects selects = Selects.builder()
+				.ids(new SqlIdColumns(field(name("person"), String.class)))
+				.sqlSelect(explicit)
+				.build();
+
+		assertTrue(selects.getValidityDate().isEmpty());
+		assertTrue(selects.getStratificationDate().isEmpty());
+		assertEquals(List.of(explicit), selects.getSqlSelects());
+		assertThrows(UnsupportedOperationException.class, () -> selects.getSqlSelects().clear());
+	}
+
+	@Test
+	void shouldPreserveAdditiveLombokBuilderBehavior() {
+		FieldWrapper<Integer> first = new FieldWrapper<>(field(name("first"), Integer.class));
+		FieldWrapper<Integer> second = new FieldWrapper<>(field(name("second"), Integer.class));
+		Selects selects = Selects.builder()
+				.ids(new SqlIdColumns(field(name("person"), String.class)))
+				.sqlSelect(first)
+				.build();
+
+		Selects extended = selects.toBuilder().sqlSelects(List.of(second)).build();
+
+		assertEquals(List.of(first, second), extended.getSqlSelects());
+	}
+
+	@Test
+	void shouldQualifyAllCompilerFields() {
+		ColumnDateRange validityDate = ColumnDateRange.of(
+				field(name("valid_from"), Date.class),
+				field(name("valid_to"), Date.class)
+		);
+		Selects selects = Selects.builder()
+				.ids(new SqlIdColumns(field(name("person"), String.class)))
+				.validityDate(Optional.of(validityDate))
+				.sqlSelect(new FieldWrapper<>(field(name("value"), Integer.class)))
+				.build();
+
+		Selects qualified = selects.qualify("step");
+
+		assertEquals(
+				List.of(name("step", "person"), name("step", "valid_from"), name("step", "valid_to"), name("step", "value")),
+				qualified.all().stream().map(Field::getQualifiedName).toList()
+		);
+		assertFalse(qualified.blockValidityDate().getValidityDate().isPresent());
+	}
+}
diff --git a/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/ir/SqlIdColumnsTest.java b/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/ir/SqlIdColumnsTest.java
new file mode 100644
index 0000000000..0d82732661
--- /dev/null
+++ b/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/ir/SqlIdColumnsTest.java
@@ -0,0 +1,71 @@
+package com.bakdata.conquery.sql.compiler.ir;
+
+import static org.jooq.impl.DSL.field;
+import static org.jooq.impl.DSL.name;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.sql.Date;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+class SqlIdColumnsTest {
+
+	@Test
+	void shouldAliasIdColumnsAndRetainTheirPredecessor() {
+		SqlIdColumns original = new SqlIdColumns(
+				field(name("source", "person"), String.class),
+				field(name("source", "visit"), String.class)
+		);
+
+		SqlIdColumns aliased = original.withAlias();
+
+		assertEquals(SharedAliases.PRIMARY_COLUMN.getAlias(), aliased.getPrimaryColumn().getName());
+		assertEquals(SharedAliases.SECONDARY_ID.getAlias(), aliased.getSecondaryId().orElseThrow().getName());
+		assertSame(original, aliased.getPredecessor().orElseThrow());
+	}
+
+	@Test
+	void shouldQualifyIdColumns() {
+		SqlIdColumns ids = new SqlIdColumns(field(name("person"), String.class));
+
+		SqlIdColumns qualified = ids.qualify("query_step");
+
+		assertEquals(name("query_step", "person"), qualified.getPrimaryColumn().getQualifiedName());
+		assertSame(ids, qualified.getPredecessor().orElseThrow());
+	}
+
+	@Test
+	void shouldCreateStratifiedIdColumnsFromNormalizedResolution() {
+		SqlIdColumns ids = new SqlIdColumns(field(name("person"), String.class));
+
+		SqlIdColumns stratified = ids.withStratification(
+				"COMPLETE",
+				field(name(SharedAliases.INDEX.getAlias()), Integer.class),
+				field(name(SharedAliases.INDEX_SELECTOR.getAlias()), Date.class)
+		);
+
+		assertTrue(stratified.isWithStratification());
+		assertEquals(
+				List.of(
+						"person",
+						SharedAliases.RESOLUTION.getAlias(),
+						SharedAliases.INDEX.getAlias(),
+						SharedAliases.INDEX_SELECTOR.getAlias()
+				),
+				stratified.toFields().stream().map(org.jooq.Field::getName).toList()
+		);
+		assertEquals(SharedAliases.INDEX.getAlias(), stratified.forFinalSelect("COMPLETE").toFields().get(2).getName());
+	}
+
+	@Test
+	void shouldRejectCoalescingStratifiedAndPlainIds() {
+		SqlIdColumns plain = new SqlIdColumns(field(name("person"), String.class));
+		SqlIdColumns stratified = plain.withStratification("YEARS", field(name("index"), Integer.class));
+
+		assertThrows(IllegalArgumentException.class, () -> stratified.coalesce(List.of(plain)));
+	}
+}
diff --git a/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/ir/select/ColumnDateRangeTest.java b/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/ir/select/ColumnDateRangeTest.java
new file mode 100644
index 0000000000..7248bff712
--- /dev/null
+++ b/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/ir/select/ColumnDateRangeTest.java
@@ -0,0 +1,45 @@
+package com.bakdata.conquery.sql.compiler.ir.select;
+
+import static org.jooq.impl.DSL.field;
+import static org.jooq.impl.DSL.name;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.sql.Date;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+class ColumnDateRangeTest {
+
+	@Test
+	void shouldAliasValidityDateColumns() {
+		ColumnDateRange range = range().asValidityDateRange("event");
+
+		assertEquals("event_validity_date", range.getAlias());
+		assertEquals("event_validity_date_start", range.getStart().getName());
+		assertEquals("event_validity_date_end", range.getEnd().getName());
+		assertEquals(List.of("event_validity_date_start", "event_validity_date_end"), range.requiredColumns());
+	}
+
+	@Test
+	void shouldQualifyAliasedDateRangeColumns() {
+		ColumnDateRange qualified = range().as("event").qualify("query_step");
+
+		assertEquals(name("query_step", "event_start"), qualified.getStart().getQualifiedName());
+		assertEquals(name("query_step", "event_end"), qualified.getEnd().getQualifiedName());
+		assertEquals("event", qualified.getAlias());
+	}
+
+	@Test
+	void shouldPreserveLeftAliasWhenCoalescing() {
+		ColumnDateRange coalesced = range().as("event").coalesce(range().as("fallback"));
+
+		assertEquals("event", coalesced.getAlias());
+		assertEquals("event_start", coalesced.getStart().getName());
+		assertEquals("event_end", coalesced.getEnd().getName());
+	}
+
+	private static ColumnDateRange range() {
+		return ColumnDateRange.of(field(name("start"), Date.class), field(name("end"), Date.class));
+	}
+}
diff --git a/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/ir/select/SqlSelectImplementationsTest.java b/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/ir/select/SqlSelectImplementationsTest.java
new file mode 100644
index 0000000000..0aba547349
--- /dev/null
+++ b/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/ir/select/SqlSelectImplementationsTest.java
@@ -0,0 +1,55 @@
+package com.bakdata.conquery.sql.compiler.ir.select;
+
+import static org.jooq.impl.DSL.field;
+import static org.jooq.impl.DSL.name;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+
+import org.jooq.Field;
+import org.junit.jupiter.api.Test;
+
+class SqlSelectImplementationsTest {
+
+	@Test
+	void shouldDeriveRequiredColumnFromFieldAlias() {
+		Field<Integer> field = field(name("source"), Integer.class).as("result");
+
+		FieldWrapper<Integer> select = new FieldWrapper<>(field);
+
+		assertEquals(List.of("result"), select.requiredColumns());
+		assertEquals("result", select.aliased().getName());
+	}
+
+	@Test
+	void shouldKeepFieldWrapperIdentityIndependentOfRequiredColumns() {
+		Field<Integer> field = field(name("source"), Integer.class).as("result");
+
+		assertEquals(new FieldWrapper<>(field, "first"), new FieldWrapper<>(field, "second"));
+	}
+
+	@Test
+	void shouldQualifyExtractingSelects() {
+		ExtractingSqlSelect<Integer> select = new ExtractingSqlSelect<>("source", "result", Integer.class);
+
+		ExtractingSqlSelect<Integer> qualified = select.qualify("next_step");
+
+		assertEquals("next_step", qualified.table());
+		assertEquals("result", qualified.column());
+		assertEquals(Integer.class, qualified.columnClass());
+		assertEquals(name("next_step", "result"), qualified.select().getQualifiedName());
+	}
+
+	@Test
+	void shouldRepresentExistenceAsUniversalSelect() {
+		ExistsSqlSelect select = ExistsSqlSelect.withAlias("present");
+
+		assertTrue(select.isUniversal());
+		assertEquals(List.of(), select.requiredColumns());
+		assertEquals("present", select.select().getName());
+		assertEquals(name("next_step", "present"), select.qualify("next_step").select().getQualifiedName());
+		assertEquals("present", select.connectorAggregate().toFields().getFirst().getName());
+		assertEquals("present", select.toFinalRepresentation().toFields().getFirst().getName());
+	}
+}
diff --git a/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/rendering/SelectProjectionRendererTest.java b/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/rendering/SelectProjectionRendererTest.java
new file mode 100644
index 0000000000..b072420159
--- /dev/null
+++ b/sql-connector/src/test/java/com/bakdata/conquery/sql/compiler/rendering/SelectProjectionRendererTest.java
@@ -0,0 +1,96 @@
+package com.bakdata.conquery.sql.compiler.rendering;
+
+import static org.jooq.impl.DSL.field;
+import static org.jooq.impl.DSL.name;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.sql.Date;
+import java.util.List;
+import java.util.Optional;
+
+import com.bakdata.conquery.sql.compiler.dialect.CompilerDialect;
+import com.bakdata.conquery.sql.compiler.ir.Selects;
+import com.bakdata.conquery.sql.compiler.ir.SharedAliases;
+import com.bakdata.conquery.sql.compiler.ir.SqlIdColumns;
+import com.bakdata.conquery.sql.compiler.ir.select.ColumnDateRange;
+import com.bakdata.conquery.sql.compiler.ir.select.FieldWrapper;
+import com.bakdata.conquery.sql.compiler.rendering.SelectProjectionRenderer.ValidityDateRendering;
+import org.jooq.Field;
+import org.junit.jupiter.api.Test;
+
+class SelectProjectionRendererTest {
+
+	@Test
+	void shouldAggregateValidityDatesForGroupedResults() {
+		RecordingDialect dialect = new RecordingDialect();
+
+		List<Field<?>> fields = SelectProjectionRenderer.render(selectsWithDates(), dialect, ValidityDateRendering.AGGREGATED);
+
+		assertEquals(
+				List.of(
+						"person",
+						SharedAliases.STRATIFICATION_BOUNDS.getAlias(),
+						SharedAliases.DATES_COLUMN.getAlias(),
+						"value"
+				),
+				fields.stream().map(Field::getName).toList()
+		);
+		assertEquals(1, dialect.aggregatedRanges);
+		assertEquals(1, dialect.renderedRanges);
+	}
+
+	@Test
+	void shouldRenderValidityDatesWithoutAggregation() {
+		RecordingDialect dialect = new RecordingDialect();
+
+		SelectProjectionRenderer.render(selectsWithDates(), dialect, ValidityDateRendering.INDIVIDUAL);
+
+		assertEquals(0, dialect.aggregatedRanges);
+		assertEquals(2, dialect.renderedRanges);
+	}
+
+	private static Selects selectsWithDates() {
+		ColumnDateRange validityDate = ColumnDateRange.of(
+				field(name("valid_from"), Date.class),
+				field(name("valid_to"), Date.class)
+		);
+		ColumnDateRange stratificationDate = ColumnDateRange.of(
+				field(name("window_from"), Date.class),
+				field(name("window_to"), Date.class)
+		);
+		return Selects.builder()
+				.ids(new SqlIdColumns(field(name("person"), String.class)))
+				.validityDate(Optional.of(validityDate))
+				.stratificationDate(Optional.of(stratificationDate))
+				.sqlSelect(new FieldWrapper<>(field(name("value"), Integer.class)))
+				.build();
+	}
+
+	private static final class RecordingDialect implements CompilerDialect {
+
+		private int renderedRanges;
+		private int aggregatedRanges;
+
+		@Override
+		public <T> Field<T> anyValue(Field<T> field) {
+			return field;
+		}
+
+		@Override
+		public Field<?> renderDateRange(Field<Date> start, Field<Date> end) {
+			this.renderedRanges++;
+			return field(name("rendered_range"), Object.class);
+		}
+
+		@Override
+		public Field<?> aggregateDateRanges(Field<Date> start, Field<Date> end) {
+			this.aggregatedRanges++;
+			return field(name("aggregated_ranges"), Object.class);
+		}
+
+		@Override
+		public int getNameMaxLength() {
+			return 128;
+		}
+	}
+}
diff --git a/sql-connector/src/test/java/com/bakdata/conquery/sql/model/BuiltInOperationsTest.java b/sql-connector/src/test/java/com/bakdata/conquery/sql/model/BuiltInOperationsTest.java
new file mode 100644
index 0000000000..5826a63192
--- /dev/null
+++ b/sql-connector/src/test/java/com/bakdata/conquery/sql/model/BuiltInOperationsTest.java
@@ -0,0 +1,164 @@
+package com.bakdata.conquery.sql.model;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static com.bakdata.conquery.sql.model.ValidationTestSupport.assertInvalid;
+import static com.bakdata.conquery.sql.model.ValidationTestSupport.assertValid;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.sql.model.operation.BuiltInAggregations;
+import com.bakdata.conquery.sql.model.operation.BuiltInConditions;
+import com.bakdata.conquery.sql.model.operation.BuiltInFilters;
+import com.bakdata.conquery.sql.model.operation.BuiltInSelects;
+import com.bakdata.conquery.sql.model.operation.ResolvedCondition;
+import com.bakdata.conquery.sql.model.operation.ResolvedFilter;
+import com.bakdata.conquery.sql.model.operation.ResolvedSelect;
+import com.bakdata.conquery.sql.model.range.NumberRange;
+import com.bakdata.conquery.sql.model.range.SubstringRange;
+import com.bakdata.conquery.sql.model.schema.DateColumns;
+import com.bakdata.conquery.sql.model.schema.ResolvedColumn;
+import com.bakdata.conquery.sql.model.schema.SqlTable;
+import org.junit.jupiter.api.Test;
+
+class BuiltInOperationsTest {
+
+	private static final SqlTable EVENTS = SqlTable.of("events", "analytics", "events");
+	private static final SqlTable OTHER_EVENTS = SqlTable.of("other-events", "analytics", "other_events");
+	private static final ResolvedColumn CODE = column("code", ColumnType.STRING);
+	private static final ResolvedColumn AMOUNT = column("amount", ColumnType.DECIMAL);
+	private static final ResolvedColumn START = column("start_date", ColumnType.DATE);
+	private static final ResolvedColumn END = column("end_date", ColumnType.DATE);
+	private static final ResolvedColumn FLAG_A = column("flag_a", ColumnType.BOOLEAN);
+	private static final ResolvedColumn FLAG_B = column("flag_b", ColumnType.BOOLEAN);
+
+	@Test
+	void shouldRepresentStandardFiltersWithResolvedInputs() {
+		ResolvedFilter values = new BuiltInFilters.StringValues(
+				CODE, Set.of("A", "B"), Optional.of(SubstringRange.between(0, 3))
+		);
+		ResolvedFilter number = new BuiltInFilters.NumericColumnRange(AMOUNT, NumberRange.closed(1, 10));
+		ResolvedFilter aggregation = new BuiltInFilters.AggregationRange(
+				new BuiltInAggregations.Sum(AMOUNT, Optional.empty(), List.of()),
+				NumberRange.atLeast(BigDecimal.TEN)
+		);
+		ResolvedFilter distance = new BuiltInFilters.DateDistanceRange(
+				START, ChronoUnit.YEARS, LocalDate.of(2026, 8, 27), NumberRange.atMost(65)
+		);
+		ResolvedFilter flags = new BuiltInFilters.Flags(
+				Map.of("A", FLAG_A, "B", FLAG_B), Set.of("A")
+		);
+
+		assertValid(values);
+		assertValid(number);
+		assertValid(aggregation);
+		assertValid(distance);
+		assertValid(flags);
+		assertInstanceOf(BuiltInFilters.StringValues.class, values);
+		assertInstanceOf(BuiltInFilters.NumericColumnRange.class, number);
+		assertInstanceOf(BuiltInFilters.AggregationRange.class, aggregation);
+		assertInstanceOf(BuiltInFilters.DateDistanceRange.class, distance);
+		assertInstanceOf(BuiltInFilters.Flags.class, flags);
+	}
+
+	@Test
+	void shouldRepresentStandardSelectsWithResolvedInputs() {
+		List<ResolvedSelect> selects = List.of(
+				new BuiltInSelects.Aggregation(new BuiltInAggregations.Count(CODE, List.of(CODE))),
+				new BuiltInSelects.Aggregation(new BuiltInAggregations.CountQuarters(new DateColumns.Pair(START, END))),
+				new BuiltInSelects.Aggregation(new BuiltInAggregations.DurationSum(new DateColumns.Pair(START, END), List.of(CODE))),
+				new BuiltInSelects.Aggregation(new BuiltInAggregations.Flags(Map.of("A", FLAG_A, "B", FLAG_B))),
+				new BuiltInSelects.Values(
+						CODE, BuiltInSelects.ValueOperation.DISTINCT, Optional.of(SubstringRange.between(0, 3))
+				),
+				new BuiltInSelects.DateUnion(new DateColumns.Pair(START, END)),
+				new BuiltInSelects.DateDistance(START, ChronoUnit.DAYS, LocalDate.of(2026, 8, 27)),
+				new BuiltInSelects.ConceptValues(List.of(CODE)),
+				new BuiltInSelects.EventDateUnion(),
+				new BuiltInSelects.EventDurationSum(),
+				new BuiltInSelects.Exists()
+		);
+
+		selects.forEach(ValidationTestSupport::assertValid);
+		assertEquals(11, selects.size());
+	}
+
+	@Test
+	void shouldRepresentDeclarativeConditions() {
+		ResolvedCondition condition = new BuiltInConditions.AllOf(List.of(
+				new BuiltInConditions.StringValues(CODE, Set.of("A")),
+				new BuiltInConditions.Presence(AMOUNT, true),
+				new BuiltInConditions.Prefixes(CODE, List.of("AB", "CD")),
+				new BuiltInConditions.Not(new BuiltInConditions.PrefixRange(CODE, "10", "20"))
+		));
+
+		assertValid(condition);
+		assertEquals(4, assertInstanceOf(BuiltInConditions.AllOf.class, condition).conditions().size());
+	}
+
+	@Test
+	void shouldDefensivelyCopyOperationCollections() {
+		List<ResolvedColumn> distinctBy = new ArrayList<>(List.of(CODE));
+		BuiltInAggregations.Count count = new BuiltInAggregations.Count(AMOUNT, distinctBy);
+		distinctBy.clear();
+
+		Map<String, ResolvedColumn> flagColumns = new LinkedHashMap<>();
+		flagColumns.put("A", FLAG_A);
+		flagColumns.put("B", FLAG_B);
+		BuiltInAggregations.Flags flags = new BuiltInAggregations.Flags(flagColumns);
+		flagColumns.clear();
+
+		assertEquals(List.of(CODE), count.distinctBy());
+		assertEquals(List.of("A", "B"), new ArrayList<>(flags.columns().keySet()));
+		assertThrows(UnsupportedOperationException.class, () -> flags.columns().clear());
+	}
+
+	@Test
+	void shouldRejectColumnsFromDifferentTablesInOneOperation() {
+		ResolvedColumn otherColumn = new ResolvedColumn(
+				"other.code", OTHER_EVENTS, "code", ColumnType.STRING, true
+		);
+
+		assertInvalid(new BuiltInAggregations.Count(CODE, List.of(otherColumn)));
+		assertInvalid(new DateColumns.Pair(START, new ResolvedColumn(
+						"other.end", OTHER_EVENTS, "end_date", ColumnType.DATE, true
+		)));
+	}
+
+	@Test
+	void shouldRejectInvalidColumnTypes() {
+		assertInvalid(new BuiltInAggregations.Sum(CODE, Optional.empty(), List.of()));
+		assertInvalid(new BuiltInFilters.DateDistanceRange(
+						CODE, ChronoUnit.DAYS, LocalDate.of(2026, 8, 27), NumberRange.unbounded()
+		));
+		assertInvalid(new BuiltInSelects.Values(
+						AMOUNT, BuiltInSelects.ValueOperation.FIRST, Optional.of(SubstringRange.from(1))
+		));
+	}
+
+	@Test
+	void shouldRejectUnknownSelectedFlags() {
+		assertInvalid(new BuiltInFilters.Flags(Map.of("A", FLAG_A), Set.of("missing")));
+	}
+
+	@Test
+	void shouldRejectInvalidRanges() {
+		assertInvalid(NumberRange.closed(2, 1));
+		assertInvalid(SubstringRange.between(3, 2));
+		assertInvalid(new BuiltInConditions.PrefixRange(CODE, "100", "20"));
+	}
+
+	private static ResolvedColumn column(String name, ColumnType type) {
+		return new ResolvedColumn("events." + name, EVENTS, name, type, true);
+	}
+}
diff --git a/sql-connector/src/test/java/com/bakdata/conquery/sql/model/ResolvedQueryTest.java b/sql-connector/src/test/java/com/bakdata/conquery/sql/model/ResolvedQueryTest.java
new file mode 100644
index 0000000000..aeea03f5e2
--- /dev/null
+++ b/sql-connector/src/test/java/com/bakdata/conquery/sql/model/ResolvedQueryTest.java
@@ -0,0 +1,163 @@
+package com.bakdata.conquery.sql.model;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static com.bakdata.conquery.sql.model.ValidationTestSupport.assertInvalid;
+import static com.bakdata.conquery.sql.model.ValidationTestSupport.assertValid;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import com.bakdata.conquery.models.datasets.ColumnType;
+import com.bakdata.conquery.sql.model.node.AndNode;
+import com.bakdata.conquery.sql.model.node.ConceptNode;
+import com.bakdata.conquery.sql.model.node.DateAggregationAction;
+import com.bakdata.conquery.sql.model.node.QueryNode;
+import com.bakdata.conquery.sql.model.range.DateRange;
+import com.bakdata.conquery.sql.model.result.ResultColumn;
+import com.bakdata.conquery.sql.model.result.ResultType;
+import com.bakdata.conquery.sql.model.schema.EntitySchema;
+import com.bakdata.conquery.sql.model.schema.ResolvedColumn;
+import com.bakdata.conquery.sql.model.schema.ResolvedConnector;
+import com.bakdata.conquery.sql.model.schema.ResolvedValidityDate;
+import com.bakdata.conquery.sql.model.schema.SqlTable;
+import com.bakdata.conquery.sql.validation.ResolvedQueryValidation;
+import jakarta.validation.ConstraintViolationException;
+import org.junit.jupiter.api.Test;
+
+class ResolvedQueryTest {
+
+	private static final SqlTable EVENTS = SqlTable.of("dataset.events", "analytics", "events");
+	private static final ResolvedColumn ENTITY_ID = new ResolvedColumn(
+			"dataset.events.entity_id", EVENTS, "entity_id", ColumnType.STRING, false
+	);
+
+	@Test
+	void shouldCreateResolvedQueryWithoutFrameworkTypes() {
+		ResolvedConnector connector = new ResolvedConnector(
+				"dataset.concept.connector",
+				EVENTS,
+				ENTITY_ID,
+				Optional.empty(),
+				new ResolvedValidityDate.Point(dateColumn("event_date")),
+				List.of(),
+				List.of(),
+				List.of()
+		);
+		ConceptNode concept = new ConceptNode(
+				"dataset.concept", List.of(connector), List.of(), DateAggregationAction.MERGE
+		);
+
+		ResolvedQuery query = new ResolvedQuery(
+				new EntitySchema(EVENTS, ENTITY_ID),
+				concept,
+				true,
+				List.of(new ResultColumn("entity", ResultType.Primitive.STRING))
+		);
+
+		assertValid(query);
+		new ResolvedQueryValidation(ValidationTestSupport.VALIDATOR).validate(query);
+		assertEquals(concept, query.root());
+	}
+
+	@Test
+	void shouldDefensivelyCopyOrderedCollections() {
+		List<QueryNode> children = new ArrayList<>();
+		children.add(conceptNode(EVENTS));
+		AndNode andNode = new AndNode(children, DateAggregationAction.INTERSECT, false);
+
+		children.add(conceptNode(EVENTS));
+
+		assertEquals(1, andNode.children().size());
+		assertThrows(UnsupportedOperationException.class, () -> andNode.children().clear());
+	}
+
+	@Test
+	void shouldRejectColumnsFromAnotherConnectorTable() {
+		SqlTable otherTable = SqlTable.of("dataset.other", "analytics", "other");
+		ResolvedColumn otherId = new ResolvedColumn(
+				"dataset.other.entity_id", otherTable, "entity_id", ColumnType.STRING, false
+		);
+
+		ResolvedConnector connector = new ResolvedConnector(
+				"dataset.concept.connector",
+				EVENTS,
+				otherId,
+				Optional.empty(),
+				new ResolvedValidityDate.None(),
+				List.of(),
+				List.of(),
+				List.of()
+		);
+
+		assertInvalid(connector);
+	}
+
+	@Test
+	void shouldRejectNonDateValidityColumns() {
+		assertInvalid(new ResolvedValidityDate.Point(ENTITY_ID));
+	}
+
+	@Test
+	void shouldRejectInvertedDateRestriction() {
+		assertInvalid(DateRange.closed(
+				LocalDate.of(2025, 2, 1),
+				LocalDate.of(2025, 1, 1)
+		));
+	}
+
+	@Test
+	void shouldValidateTheCompleteQueryGraphAtTheCompilerBoundary() {
+		ResolvedConnector invalidConnector = new ResolvedConnector(
+				"concept.connector",
+				EVENTS,
+				ENTITY_ID,
+				Optional.empty(),
+				new ResolvedValidityDate.Point(ENTITY_ID),
+				List.of(),
+				List.of(),
+				List.of()
+		);
+		ResolvedQuery query = new ResolvedQuery(
+				new EntitySchema(EVENTS, ENTITY_ID),
+				new ConceptNode("concept", List.of(invalidConnector), List.of(), DateAggregationAction.MERGE),
+				true,
+				List.of()
+		);
+
+		assertThrows(
+				ConstraintViolationException.class,
+				() -> new ResolvedQueryValidation(ValidationTestSupport.VALIDATOR).validate(query)
+		);
+	}
+
+	@Test
+	void shouldRejectAmbiguousResultColumnIds() {
+		ResolvedQuery query = new ResolvedQuery(
+				new EntitySchema(EVENTS, ENTITY_ID),
+				conceptNode(EVENTS),
+				false,
+				List.of(
+						new ResultColumn("duplicate", ResultType.Primitive.STRING),
+						new ResultColumn("duplicate", ResultType.Primitive.BOOLEAN)
+				)
+		);
+
+		assertInvalid(query);
+	}
+
+	private static ConceptNode conceptNode(SqlTable table) {
+		ResolvedColumn id = new ResolvedColumn("concept.id", table, "entity_id", ColumnType.STRING, false);
+		ResolvedConnector connector = new ResolvedConnector(
+				"concept.connector", table, id, Optional.empty(), new ResolvedValidityDate.None(),
+				List.of(), List.of(), List.of()
+		);
+		return new ConceptNode("concept", List.of(connector), List.of(), DateAggregationAction.BLOCK);
+	}
+
+	private static ResolvedColumn dateColumn(String name) {
+		return new ResolvedColumn("dataset.events." + name, EVENTS, name, ColumnType.DATE, true);
+	}
+}
diff --git a/sql-connector/src/test/java/com/bakdata/conquery/sql/model/ValidationTestSupport.java b/sql-connector/src/test/java/com/bakdata/conquery/sql/model/ValidationTestSupport.java
new file mode 100644
index 0000000000..f15fb5ddcd
--- /dev/null
+++ b/sql-connector/src/test/java/com/bakdata/conquery/sql/model/ValidationTestSupport.java
@@ -0,0 +1,28 @@
+package com.bakdata.conquery.sql.model;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Set;
+
+import jakarta.validation.ConstraintViolation;
+import jakarta.validation.Validation;
+import jakarta.validation.Validator;
+
+public final class ValidationTestSupport {
+
+	public static final Validator VALIDATOR = Validation.buildDefaultValidatorFactory().getValidator();
+
+	private ValidationTestSupport() {
+	}
+
+	public static <T> void assertValid(T value) {
+		Set<ConstraintViolation<T>> violations = VALIDATOR.validate(value);
+		assertTrue(violations.isEmpty(), () -> "Expected no constraint violations, but got: " + violations);
+	}
+
+	public static <T> void assertInvalid(T value) {
+		Set<ConstraintViolation<T>> violations = VALIDATOR.validate(value);
+		assertFalse(violations.isEmpty(), "Expected at least one constraint violation");
+	}
+}