diff --git a/calm-hub/.gitignore b/calm-hub/.gitignore
index ee1b34071..049281bf5 100644
--- a/calm-hub/.gitignore
+++ b/calm-hub/.gitignore
@@ -42,7 +42,7 @@
 # .idea/modules.xml
 # .idea/*.iml
 # .idea/modules
-# *.iml
+*.iml
 # *.ipr
 
 # CMake
@@ -316,4 +316,4 @@ thumb
 sketch
 
 
-# End of https://www.toptal.com/developers/gitignore/api/intellij,react,node,java,maven
\ No newline at end of file
+# End of https://www.toptal.com/developers/gitignore/api/intellij,react,node,java,maven
diff --git a/calm-hub/mongo/init-mongo.js b/calm-hub/mongo/init-mongo.js
index 09044f782..849e1d8f5 100644
--- a/calm-hub/mongo/init-mongo.js
+++ b/calm-hub/mongo/init-mongo.js
@@ -21,6 +21,17 @@ if (db.counters.countDocuments({ _id: "architectureStoreCounter" }) === 1) {
     print("architectureStoreCounter already exists, no initialization needed");
 }
 
+if (db.counters.countDocuments({ _id: "adrStoreCounter" }) === 1) {
+    db.counters.insertOne({
+        _id: "adrStoreCounter",
+        sequence_value: 1
+    });
+    print("Initialized adrStoreCounter with sequence_value 1");
+} else {
+    print("adrStoreCounter already exists, no initialization needed");
+}
+
+
 if (db.counters.countDocuments({ _id: "flowStoreCounter" }) === 1) {
     db.counters.insertOne({
         _id: "flowStoreCounter",
diff --git a/calm-hub/pom.xml b/calm-hub/pom.xml
index a95f1db59..9fb82398c 100644
--- a/calm-hub/pom.xml
+++ b/calm-hub/pom.xml
@@ -44,6 +44,16 @@
       <groupId>io.quarkus</groupId>
       <artifactId>quarkus-mongodb-client</artifactId>
     </dependency>
+    <dependency>
+      <groupId>io.soabase.record-builder</groupId>
+      <artifactId>record-builder-core</artifactId>
+      <version>44</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.datatype</groupId>
+      <artifactId>jackson-datatype-jsr310</artifactId>
+    </dependency>
 
     <!-- Testing -->
     <dependency>
@@ -165,6 +175,11 @@
       <groupId>org.jacoco</groupId>
       <artifactId>jacoco-maven-plugin</artifactId>
       <version>0.8.12</version>
+        <configuration>
+        <excludes>
+          <exclude>**/*Builder.*</exclude>
+        </excludes>
+      </configuration>
       <executions>
         <execution>
           <id>default-prepare-agent</id>
@@ -200,6 +215,21 @@
         </execution>
       </executions>
     </plugin>
+
+    <!-- Record Builder Plugin -->
+    <plugin>
+      <groupId>org.apache.maven.plugins</groupId>
+      <artifactId>maven-compiler-plugin</artifactId>
+      <configuration>
+        <annotationProcessorPaths>
+          <path>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-processor</artifactId>
+            <version>44</version>
+          </path>
+        </annotationProcessorPaths>
+      </configuration>
+    </plugin>
     </plugins>
   </build>
   <profiles>
diff --git a/calm-hub/src/integration-test/java/integration/MongoAdrIntegration.java b/calm-hub/src/integration-test/java/integration/MongoAdrIntegration.java
new file mode 100644
index 000000000..1c3f15388
--- /dev/null
+++ b/calm-hub/src/integration-test/java/integration/MongoAdrIntegration.java
@@ -0,0 +1,210 @@
+package integration;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoClients;
+import com.mongodb.client.MongoDatabase;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.junit.TestProfile;
+import org.bson.Document;
+import org.eclipse.microprofile.config.ConfigProvider;
+import org.finos.calm.domain.adr.Adr;
+import org.finos.calm.domain.adr.AdrMeta;
+import org.finos.calm.domain.adr.AdrMetaBuilder;
+import org.finos.calm.domain.adr.Decision;
+import org.finos.calm.domain.adr.DecisionBuilder;
+import org.finos.calm.domain.adr.LinkBuilder;
+import org.finos.calm.domain.adr.NewAdrRequest;
+import org.finos.calm.domain.adr.NewAdrRequestBuilder;
+import org.finos.calm.domain.adr.Option;
+import org.finos.calm.domain.adr.OptionBuilder;
+import org.finos.calm.domain.adr.Status;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import static integration.MongoSetup.counterSetup;
+import static integration.MongoSetup.namespaceSetup;
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@QuarkusTest
+@TestProfile(IntegrationTestProfile.class)
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+public class MongoAdrIntegration {
+
+    private ObjectMapper objectMapper;
+
+    private static final Logger logger = LoggerFactory.getLogger(MongoAdrIntegration.class);
+
+    private final String TITLE = "My ADR";
+    private final String PROBLEM_STATEMENT = "My problem is...";
+    private final List<String> DECISION_DRIVERS = List.of("a", "b", "c");
+    private final Option OPTION_A = OptionBuilder.builder().name("Option 1").description("optionDescription")
+            .positiveConsequences(List.of("a")).negativeConsequences(List.of("b")).build();
+    private final Option OPTION_B = OptionBuilder.builder().name("Option 2").description("optionDescription")
+            .positiveConsequences(List.of("c")).negativeConsequences(List.of("d")).build();
+    private final List<Option> CONSIDERED_OPTIONS = List.of(OPTION_A, OPTION_B);
+    private final String RATIONALE = "This is the best option";
+    private final Decision DECISION_OUTCOME = DecisionBuilder.builder()
+            .rationale(RATIONALE)
+            .chosenOption(OPTION_A)
+            .build();
+
+    private final NewAdrRequest newAdr = NewAdrRequestBuilder.builder()
+            .title(TITLE)
+            .contextAndProblemStatement(PROBLEM_STATEMENT)
+            .decisionDrivers(DECISION_DRIVERS)
+            .consideredOptions(CONSIDERED_OPTIONS)
+            .decisionOutcome(DECISION_OUTCOME)
+            .links(List.of(LinkBuilder.builder().rel("abc").href("http://abc.com").build()))
+            .build();
+
+    private final Adr adr = Adr.builderFromNewAdr(newAdr).status(Status.draft).build();
+
+    @BeforeEach
+    public void setupAdrs() {
+        String mongoUri = ConfigProvider.getConfig().getValue("quarkus.mongodb.connection-string", String.class);
+
+        // Safeguard: Fail fast if URI is not set
+        if(mongoUri == null || mongoUri.isBlank()) {
+            logger.error("MongoDB URI is not set. Check the EndToEndResource configuration.");
+            throw new IllegalStateException("MongoDB URI is not set. Check the EndToEndResource configuration.");
+        }
+
+        try(MongoClient mongoClient = MongoClients.create(mongoUri)) {
+            MongoDatabase database = mongoClient.getDatabase("calmSchemas");
+
+            if(!database.listCollectionNames().into(new ArrayList<>()).contains("adrs")) {
+                database.createCollection("adrs");
+                database.getCollection("adrs").insertOne(
+                        new Document("namespace", "finos").append("adrs", new ArrayList<>())
+                );
+            }
+
+            counterSetup(database);
+            namespaceSetup(database);
+        }
+        this.objectMapper = new ObjectMapper();
+        objectMapper.registerModule(new JavaTimeModule());
+    }
+
+    @Test
+    @Order(1)
+    void end_to_end_verify_get_with_no_architecture() {
+        given()
+                .when().get("/calm/namespaces/finos/adrs")
+                .then()
+                .statusCode(200)
+                .body("values", empty());
+    }
+
+    @Test
+    @Order(2)
+    void end_to_end_verify_create_an_adr() throws JsonProcessingException {
+        given()
+                .body(objectMapper.writeValueAsString(newAdr))
+                .header("Content-Type", "application/json")
+                .when().post("/calm/namespaces/finos/adrs")
+                .then()
+                .statusCode(201)
+                .header("Location", containsString("calm/namespaces/finos/adrs/1"));
+    }
+
+    @Test
+    @Order(3)
+    void end_to_end_verify_get_adr_revision() throws JsonProcessingException {
+        AdrMeta expectedAdrMeta = AdrMetaBuilder.builder()
+                .namespace("finos")
+                .id(1)
+                .revision(1)
+                .adrContent(adr)
+                .build();
+
+        AdrMeta actualAdrMeta = given()
+                .when().get("/calm/namespaces/finos/adrs/1/revisions/1")
+                .then()
+                .statusCode(200)
+                .extract()
+                .body()
+                .as(AdrMeta.class);
+        assertEquals(expectedAdrMeta, actualAdrMeta);
+    }
+
+    @Test
+    @Order(4)
+    void end_to_end_verify_get_adr() {
+        AdrMeta actualAdrMeta = given()
+                .when().get("/calm/namespaces/finos/adrs/1")
+                .then()
+                .statusCode(200)
+                .extract()
+                .body()
+                .as(AdrMeta.class);
+
+        AdrMeta expectedAdrMeta = AdrMetaBuilder.builder()
+                .namespace("finos")
+                .id(1)
+                .revision(1)
+                .adrContent(adr)
+                .build();
+        assertEquals(expectedAdrMeta, actualAdrMeta);
+    }
+
+    @Test
+    @Order(5)
+    void end_to_end_verify_update_an_adr() throws JsonProcessingException {
+        given()
+                .body(objectMapper.writeValueAsString(newAdr))
+                .header("Content-Type", "application/json")
+                .when().post("/calm/namespaces/finos/adrs/1")
+                .then()
+                .statusCode(201)
+                .header("Location", containsString("calm/namespaces/finos/adrs/1"));
+    }
+
+    @Test
+    @Order(6)
+    void end_to_end_verify_get_revisions() {
+        given()
+                .when().get("/calm/namespaces/finos/adrs/1/revisions")
+                .then()
+                .statusCode(200)
+                .body("values", hasSize(2))
+                .body("values[0]", equalTo(1))
+                .body("values[1]", equalTo(2));
+
+    }
+
+    @Test
+    @Order(7)
+    void end_to_end_verify_update_an_adr_status() throws JsonProcessingException {
+        given()
+                .when().post("/calm/namespaces/finos/adrs/1/status/proposed")
+                .then()
+                .statusCode(201)
+                .header("Location", containsString("calm/namespaces/finos/adrs/1"));
+    }
+
+    @Test
+    @Order(8)
+    void end_to_end_verify_status_changed() throws JsonProcessingException {
+
+        given()
+                .when().get("/calm/namespaces/finos/adrs/1/revisions/3")
+                .then()
+                .statusCode(200)
+                .body("adrContent.status", equalTo("proposed"));
+    }
+
+}
\ No newline at end of file
diff --git a/calm-hub/src/integration-test/java/integration/MongoArchitectureIntegration.java b/calm-hub/src/integration-test/java/integration/MongoArchitectureIntegration.java
index c425c6d12..5420d0f6e 100644
--- a/calm-hub/src/integration-test/java/integration/MongoArchitectureIntegration.java
+++ b/calm-hub/src/integration-test/java/integration/MongoArchitectureIntegration.java
@@ -3,7 +3,6 @@
 import com.mongodb.client.MongoClient;
 import com.mongodb.client.MongoClients;
 import com.mongodb.client.MongoDatabase;
-import io.quarkus.test.common.QuarkusTestResource;
 import io.quarkus.test.junit.QuarkusTest;
 import io.quarkus.test.junit.TestProfile;
 import org.bson.Document;
diff --git a/calm-hub/src/integration-test/java/integration/MongoSetup.java b/calm-hub/src/integration-test/java/integration/MongoSetup.java
index b4b2ee0e8..3a5402ee0 100644
--- a/calm-hub/src/integration-test/java/integration/MongoSetup.java
+++ b/calm-hub/src/integration-test/java/integration/MongoSetup.java
@@ -25,8 +25,10 @@ public static void counterSetup(MongoDatabase database) {
             database.createCollection("counters");
             Document patternStoreCounter = new Document("_id", "patternStoreCounter").append("sequence_value", 0);
             Document architectureStoreCounter = new Document("_id", "architectureStoreCounter").append("sequence_value", 0);
+            Document adrStoreCounter = new Document("_id", "adrStoreCounter").append("sequence_value", 0);
             database.getCollection("counters").insertOne(patternStoreCounter);
             database.getCollection("counters").insertOne(architectureStoreCounter);
+            database.getCollection("counters").insertOne(adrStoreCounter);
         }
     }
 }
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/adr/Adr.java b/calm-hub/src/main/java/org/finos/calm/domain/adr/Adr.java
new file mode 100644
index 000000000..126ca4980
--- /dev/null
+++ b/calm-hub/src/main/java/org/finos/calm/domain/adr/Adr.java
@@ -0,0 +1,61 @@
+package org.finos.calm.domain.adr;
+
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
+import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Objects;
+
+@RecordBuilder.Options(enableWither = false)
+@RecordBuilder
+public record Adr(
+        String title,
+        Status status,
+        @JsonDeserialize(using = LocalDateTimeDeserializer.class)
+        @JsonSerialize(using = LocalDateTimeSerializer.class)
+        LocalDateTime creationDateTime,
+        @JsonDeserialize(using = LocalDateTimeDeserializer.class)
+        @JsonSerialize(using = LocalDateTimeSerializer.class)
+        LocalDateTime updateDateTime,
+        String contextAndProblemStatement,
+        List<String> decisionDrivers,
+        List<Option> consideredOptions,
+        Decision decisionOutcome,
+        List<Link> links
+
+) {
+
+    public static AdrBuilder builderFromNewAdr(NewAdrRequest newAdrRequest) {
+        return AdrBuilder.builder()
+                .title(newAdrRequest.title())
+                .contextAndProblemStatement(newAdrRequest.contextAndProblemStatement())
+                .decisionDrivers(newAdrRequest.decisionDrivers())
+                .consideredOptions(newAdrRequest.consideredOptions())
+                .decisionOutcome(newAdrRequest.decisionOutcome())
+                .links(newAdrRequest.links());
+    }
+
+    // does not include datetimes in equals
+    @Override
+    public boolean equals(Object o) {
+        if(this == o) return true;
+        if(o == null || getClass() != o.getClass()) return false;
+        Adr that = (Adr) o;
+        return Objects.equals(title, that.title) &&
+                status == that.status &&
+                Objects.equals(contextAndProblemStatement, that.contextAndProblemStatement) &&
+                Objects.equals(decisionDrivers, that.decisionDrivers) &&
+                Objects.equals(consideredOptions, that.consideredOptions) &&
+                Objects.equals(decisionOutcome, that.decisionOutcome) &&
+                Objects.equals(links, that.links);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(title, status, contextAndProblemStatement, decisionDrivers, consideredOptions, decisionOutcome, links);
+    }
+}
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/adr/AdrMeta.java b/calm-hub/src/main/java/org/finos/calm/domain/adr/AdrMeta.java
new file mode 100644
index 000000000..6f56f1312
--- /dev/null
+++ b/calm-hub/src/main/java/org/finos/calm/domain/adr/AdrMeta.java
@@ -0,0 +1,13 @@
+package org.finos.calm.domain.adr;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+/**
+ * Represents an ADR and the associated namespace, id, and revision.
+ * The ADR is represented as a String in JSON format.
+ */
+@RecordBuilder.Options(enableWither = false)
+@RecordBuilder
+public record AdrMeta(String namespace, int id, int revision, Adr adrContent) {
+
+}
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/adr/Decision.java b/calm-hub/src/main/java/org/finos/calm/domain/adr/Decision.java
new file mode 100644
index 000000000..0aac4805d
--- /dev/null
+++ b/calm-hub/src/main/java/org/finos/calm/domain/adr/Decision.java
@@ -0,0 +1,8 @@
+package org.finos.calm.domain.adr;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder.Options(enableWither = false)
+@RecordBuilder
+public record Decision(Option chosenOption, String rationale) {
+}
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/adr/Link.java b/calm-hub/src/main/java/org/finos/calm/domain/adr/Link.java
new file mode 100644
index 000000000..4f5ff57a1
--- /dev/null
+++ b/calm-hub/src/main/java/org/finos/calm/domain/adr/Link.java
@@ -0,0 +1,8 @@
+package org.finos.calm.domain.adr;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder.Options(enableWither = false)
+@RecordBuilder
+public record Link(String rel, String href) {
+}
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/adr/NewAdrRequest.java b/calm-hub/src/main/java/org/finos/calm/domain/adr/NewAdrRequest.java
new file mode 100644
index 000000000..9a076b4f3
--- /dev/null
+++ b/calm-hub/src/main/java/org/finos/calm/domain/adr/NewAdrRequest.java
@@ -0,0 +1,17 @@
+package org.finos.calm.domain.adr;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import java.util.List;
+
+@RecordBuilder.Options(enableWither = false)
+@RecordBuilder
+public record NewAdrRequest(
+    String title,
+    String contextAndProblemStatement,
+    List<String> decisionDrivers,
+    List<Option> consideredOptions,
+    Decision decisionOutcome,
+    List<Link> links
+) {
+}
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/adr/Option.java b/calm-hub/src/main/java/org/finos/calm/domain/adr/Option.java
new file mode 100644
index 000000000..4db4dfe4d
--- /dev/null
+++ b/calm-hub/src/main/java/org/finos/calm/domain/adr/Option.java
@@ -0,0 +1,10 @@
+package org.finos.calm.domain.adr;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import java.util.List;
+
+@RecordBuilder.Options(enableWither = false)
+@RecordBuilder
+public record Option(String name, String description, List<String> positiveConsequences, List<String> negativeConsequences) {
+}
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/adr/Status.java b/calm-hub/src/main/java/org/finos/calm/domain/adr/Status.java
new file mode 100644
index 000000000..309aafe38
--- /dev/null
+++ b/calm-hub/src/main/java/org/finos/calm/domain/adr/Status.java
@@ -0,0 +1,10 @@
+package org.finos.calm.domain.adr;
+
+public enum Status {
+    draft,
+    proposed,
+    accepted,
+    superseded,
+    rejected,
+    deprecated;
+}
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/exception/AdrNotFoundException.java b/calm-hub/src/main/java/org/finos/calm/domain/exception/AdrNotFoundException.java
new file mode 100644
index 000000000..a157439a8
--- /dev/null
+++ b/calm-hub/src/main/java/org/finos/calm/domain/exception/AdrNotFoundException.java
@@ -0,0 +1,7 @@
+package org.finos.calm.domain.exception;
+
+/**
+ * Exception thrown when the specified ADR is not found.
+ */
+public class AdrNotFoundException extends Exception {
+}
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/exception/AdrParseException.java b/calm-hub/src/main/java/org/finos/calm/domain/exception/AdrParseException.java
new file mode 100644
index 000000000..f727c6121
--- /dev/null
+++ b/calm-hub/src/main/java/org/finos/calm/domain/exception/AdrParseException.java
@@ -0,0 +1,4 @@
+package org.finos.calm.domain.exception;
+
+public class AdrParseException extends Exception {
+}
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/exception/AdrPersistenceException.java b/calm-hub/src/main/java/org/finos/calm/domain/exception/AdrPersistenceException.java
new file mode 100644
index 000000000..078f3f450
--- /dev/null
+++ b/calm-hub/src/main/java/org/finos/calm/domain/exception/AdrPersistenceException.java
@@ -0,0 +1,4 @@
+package org.finos.calm.domain.exception;
+
+public class AdrPersistenceException extends Exception {
+}
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/exception/AdrRevisionNotFoundException.java b/calm-hub/src/main/java/org/finos/calm/domain/exception/AdrRevisionNotFoundException.java
new file mode 100644
index 000000000..4f10f75c0
--- /dev/null
+++ b/calm-hub/src/main/java/org/finos/calm/domain/exception/AdrRevisionNotFoundException.java
@@ -0,0 +1,7 @@
+package org.finos.calm.domain.exception;
+
+/**
+ * Exception thrown when the specified ADR revision is not found.
+ */
+public class AdrRevisionNotFoundException extends Exception {
+}
diff --git a/calm-hub/src/main/java/org/finos/calm/resources/AdrResource.java b/calm-hub/src/main/java/org/finos/calm/resources/AdrResource.java
new file mode 100644
index 000000000..1840210e2
--- /dev/null
+++ b/calm-hub/src/main/java/org/finos/calm/resources/AdrResource.java
@@ -0,0 +1,321 @@
+package org.finos.calm.resources;
+
+import jakarta.ws.rs.Consumes;
+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 jakarta.ws.rs.core.Response;
+import org.eclipse.microprofile.openapi.annotations.Operation;
+import org.eclipse.microprofile.openapi.annotations.media.Content;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
+import org.eclipse.microprofile.openapi.annotations.responses.APIResponses;
+import org.finos.calm.domain.adr.Adr;
+import org.finos.calm.domain.adr.AdrMeta;
+import org.finos.calm.domain.adr.AdrMetaBuilder;
+import org.finos.calm.domain.adr.Status;
+import org.finos.calm.domain.adr.NewAdrRequest;
+import org.finos.calm.domain.ValueWrapper;
+import org.finos.calm.domain.exception.AdrNotFoundException;
+import org.finos.calm.domain.exception.AdrParseException;
+import org.finos.calm.domain.exception.AdrPersistenceException;
+import org.finos.calm.domain.exception.AdrRevisionNotFoundException;
+import org.finos.calm.domain.exception.NamespaceNotFoundException;
+import org.finos.calm.store.AdrStore;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.time.LocalDateTime;
+import java.util.Map;
+import java.util.function.Function;
+
+/**
+ * Resource for managing ADRs in a given namespace
+ */
+@Path("/calm/namespaces")
+public class AdrResource {
+
+    private final AdrStore store;
+    private final Logger logger = LoggerFactory.getLogger(AdrResource.class);
+
+    public AdrResource(AdrStore store) {
+        this.store = store;
+    }
+
+    /**
+     * Retrieve a list of ADRs in a given namespace
+     *
+     * @param namespace the namespace to retrieve ADRs for
+     * @return a list of ADRs in the given namespace
+     */
+    @GET
+    @Path("{namespace}/adrs")
+    @Produces(MediaType.APPLICATION_JSON)
+    @Operation(
+            summary = "Retrieve ADRs in a given namespace",
+            description = "ADRs stored in a given namespace"
+    )
+    public Response getAdrsForNamespace(@PathParam("namespace") String namespace) {
+        try {
+            return Response.ok(new ValueWrapper<>(store.getAdrsForNamespace(namespace))).build();
+        } catch(Exception e) {
+            return handleException(e, namespace);
+        }
+    }
+
+    /**
+     * Create a new ADR in the DRAFT state
+     *
+     * @param namespace the namespace to create the ADR in
+     * @param newAdrRequest    the new ADR to be created
+     * @return created response with Location header
+     */
+    @POST
+    @Path("{namespace}/adrs")
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    @Operation(
+            summary = "Create ADR for namespace",
+            description = "Creates an ADR for a given namespace with an allocated ID and revision 1"
+    )
+    public Response createAdrForNamespace(@PathParam("namespace") String namespace, NewAdrRequest newAdrRequest) {
+        Adr adrContent = Adr.builderFromNewAdr(newAdrRequest)
+                .status(Status.draft)
+                .creationDateTime(LocalDateTime.now())
+                .updateDateTime(LocalDateTime.now())
+                .build();
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(namespace)
+                .revision(1)
+                .adrContent(adrContent)
+                .build();
+
+        try {
+            return adrWithLocationResponse(store.createAdrForNamespace(adrMeta));
+        } catch(Exception e) {
+            return handleException(e, namespace);
+        }
+    }
+
+    /**
+     * Update an existing ADRs contents
+     *
+     * @param namespace      the namespace the ADR is in
+     * @param adrId          the ID of the ADR
+     * @param newAdrRequest the new ADR content
+     * @return created with a Location header
+     */
+    @POST
+    @Path("{namespace}/adrs/{adrId}")
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    @Operation(
+            summary = "Update ADR for namespace",
+            description = "Updates an ADR for a given namespace. Creates a new revision."
+    )
+    public Response updateAdrForNamespace(@PathParam("namespace") String namespace, @PathParam("adrId") int adrId, NewAdrRequest newAdrRequest) {
+        Adr adrContent = Adr.builderFromNewAdr(newAdrRequest)
+                .updateDateTime(LocalDateTime.now())
+                .build();
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(namespace)
+                .id(adrId)
+                .adrContent(adrContent)
+                .build();
+
+        try {
+            return adrWithLocationResponse(store.updateAdrForNamespace(adrMeta));
+        } catch(Exception e) {
+            return handleException(e, namespace);
+        }
+    }
+
+    /**
+     * Gets the latest revision of an ADR
+     *
+     * @param namespace the namespace the ADR belongs to
+     * @param adrId     the ID of the requested ADR
+     * @return the requested ADR document
+     */
+    @GET
+    @Path("{namespace}/adrs/{adrId}")
+    @Produces(MediaType.APPLICATION_JSON)
+    @Operation(
+            summary = "Retrieve the latest revision of an ADR",
+            description = "Retrieve the latest revision of an ADR"
+    )
+    @APIResponses(value = {
+            @APIResponse(
+                    responseCode = "200",
+                    content = @Content(schema = @Schema(implementation = AdrMeta.class))
+            )
+    })
+    public Response getAdr(@PathParam("namespace") String namespace, @PathParam("adrId") int adrId) {
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(namespace)
+                .id(adrId)
+                .build();
+
+        try {
+            return Response.ok(store.getAdr(adrMeta)).build();
+        } catch(Exception e) {
+            return handleException(e, namespace, adrId);
+        }
+    }
+
+    /**
+     * Gets the list of revisions of an ADR
+     *
+     * @param namespace the namespace the ADR belongs to
+     * @param adrId     the ID of the requested ADR
+     * @return a list of revision numbers
+     */
+    @GET
+    @Path("{namespace}/adrs/{adrId}/revisions")
+    @Produces(MediaType.APPLICATION_JSON)
+    @Operation(
+            summary = "Retrieve a list of revisions for a given ADR",
+            description = "The most recent revision is the canonical ADR, with others available for audit or exploring changes."
+    )
+    public Response getAdrRevisions(@PathParam("namespace") String namespace, @PathParam("adrId") int adrId) {
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(namespace)
+                .id(adrId)
+                .build();
+
+        try {
+            return Response.ok(new ValueWrapper<>(store.getAdrRevisions(adrMeta))).build();
+        } catch(NamespaceNotFoundException | AdrNotFoundException | AdrRevisionNotFoundException e) {
+            return handleException(e, namespace, adrId);
+        }
+    }
+
+    /**
+     * Gets a specific revision of an ADR
+     *
+     * @param namespace the namespace the ADR belongs to
+     * @param adrId     the ID of the requested ADR
+     * @param revision  the revision of the ADR being requested
+     * @return the requested revision of the requested ADR
+     */
+    @GET
+    @Path("{namespace}/adrs/{adrId}/revisions/{revision}")
+    @Produces(MediaType.APPLICATION_JSON)
+    @Operation(
+            summary = "Retrieve a specific revision of an ADR",
+            description = "Retrieve a specific revision of an ADR"
+    )
+    @APIResponses(value = {
+            @APIResponse(
+                    responseCode = "200",
+                    content = @Content(schema = @Schema(implementation = AdrMeta.class))
+            )
+    })
+    public Response getAdrRevision(@PathParam("namespace") String namespace, @PathParam("adrId") int adrId, @PathParam("revision") int revision) {
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(namespace)
+                .id(adrId)
+                .revision(revision)
+                .build();
+
+        try {
+            return Response.ok(store.getAdrRevision(adrMeta)).build();
+        } catch(Exception e) {
+            return handleException(e, namespace, adrId, revision);
+        }
+    }
+
+    /**
+     * Update the status of an existing ADR
+     *
+     * @param namespace the namespace the ADR is in
+     * @param adrId     the ID of the ADR
+     * @param status the new status of the ADR
+     * @return created with a Location header
+     * @throws URISyntaxException cannot produce Location header
+     */
+    @POST
+    @Path("{namespace}/adrs/{adrId}/status/{status}")
+    @Produces(MediaType.APPLICATION_JSON)
+    @Operation(
+            summary = "Update the status of ADR for namespace",
+            description = "Updates the status of an ADR for a given namespace. Creates a new revision."
+    )
+    public Response updateAdrStatusForNamespace(@PathParam("namespace") String namespace, @PathParam("adrId") int adrId, @PathParam("status") Status status) throws URISyntaxException {
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(namespace)
+                .id(adrId)
+                .build();
+
+        try {
+            return adrWithLocationResponse(store.updateAdrStatus(adrMeta, status));
+        } catch(Exception e) {
+            return handleException(e, namespace, adrId);
+        }
+    }
+
+    private Response adrWithLocationResponse(AdrMeta adrMeta) throws URISyntaxException {
+        return Response.created(new URI("/calm/namespaces/" + adrMeta.namespace() + "/adrs/" + adrMeta.id() + "/revisions/" + adrMeta.revision())).build();
+    }
+
+    private Response handleException(Exception e, String namespace) {
+        return handleException(e, namespace, 0, 0);
+    }
+
+    private Response handleException(Exception e, String namespace, int adrId) {
+        return handleException(e, namespace, adrId, 0);
+    }
+
+    private Response handleException(Exception e, String namespace, int adrId, int revision) {
+        Map<Class<? extends Exception>, Function<Exception, Response>> handlers = Map.of(
+                NamespaceNotFoundException.class, ex -> handleNamespaceNotFoundException(namespace, ex),
+                AdrNotFoundException.class, ex -> handleAdrNotFoundException(adrId, ex),
+                AdrRevisionNotFoundException.class, ex -> handleAdrRevisionNotFoundException(adrId, revision, ex),
+                AdrParseException.class, this::handleAdrParseException,
+                AdrPersistenceException.class, ex -> handleAdrPersistenceException(adrId, ex)
+        );
+
+        return handlers.getOrDefault(e.getClass(), ex -> {
+            logger.error("Unexpected exception occurred", ex);
+            return Response.serverError().build();
+        }).apply(e);
+    }
+
+    private Response handleNamespaceNotFoundException(String namespace, Exception ex) {
+        logger.error("Could not find namespace [{}]", namespace, ex);
+        return Response.status(Response.Status.NOT_FOUND).entity("Could not find namespace: " + namespace).build();
+    }
+
+    private Response handleAdrNotFoundException(int adrId, Exception ex) {
+        logger.error("Could not find ADR [{}]", adrId, ex);
+        return Response.status(Response.Status.NOT_FOUND).entity("Could not find ADR: " + adrId).build();
+    }
+
+    private Response handleAdrRevisionNotFoundException(int adrId, int revision, Exception ex) {
+        if(revision == 0) {
+            logger.error("Could not find latest revision of ADR [{}]", adrId, ex);
+            return Response.status(Response.Status.NOT_FOUND).entity("Latest revision not found for ADR: [{}]: " + adrId).build();
+        } else {
+            logger.error("Could not find revision [{}] of ADR [{}]", revision, adrId, ex);
+            return Response.status(Response.Status.NOT_FOUND).entity("Revision " + revision + " not found for ADR: [{}]: " + adrId).build();
+        }
+    }
+
+    private Response handleAdrParseException(Exception ex) {
+        logger.error("Could not parse ADR JSON", ex);
+        return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity("Could not parse ADR JSON").build();
+    }
+
+    private Response handleAdrPersistenceException(int adrId, Exception ex) {
+        logger.error("Could not persist update of ADR [{}]", adrId, ex);
+        return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity("Could not persist update of ADR: [{}]:" + adrId).build();
+    }
+}
\ No newline at end of file
diff --git a/calm-hub/src/main/java/org/finos/calm/store/AdrStore.java b/calm-hub/src/main/java/org/finos/calm/store/AdrStore.java
new file mode 100644
index 000000000..dd8011320
--- /dev/null
+++ b/calm-hub/src/main/java/org/finos/calm/store/AdrStore.java
@@ -0,0 +1,22 @@
+package org.finos.calm.store;
+
+import org.finos.calm.domain.adr.AdrMeta;
+import org.finos.calm.domain.adr.Status;
+import org.finos.calm.domain.exception.AdrNotFoundException;
+import org.finos.calm.domain.exception.AdrParseException;
+import org.finos.calm.domain.exception.AdrPersistenceException;
+import org.finos.calm.domain.exception.AdrRevisionNotFoundException;
+import org.finos.calm.domain.exception.NamespaceNotFoundException;
+
+import java.util.List;
+
+public interface AdrStore {
+
+    List<Integer> getAdrsForNamespace(String namespace) throws NamespaceNotFoundException;
+    AdrMeta createAdrForNamespace(AdrMeta adrMeta) throws NamespaceNotFoundException, AdrParseException;
+    AdrMeta getAdr(AdrMeta adrMeta) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, AdrParseException;
+    List<Integer> getAdrRevisions(AdrMeta adrMeta) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException;
+    AdrMeta getAdrRevision(AdrMeta adrMeta) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, AdrParseException;
+    AdrMeta updateAdrForNamespace(AdrMeta adrMeta) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, AdrPersistenceException, AdrParseException;
+    AdrMeta updateAdrStatus(AdrMeta adrMeta, Status status) throws AdrNotFoundException, NamespaceNotFoundException, AdrRevisionNotFoundException, AdrPersistenceException, AdrParseException;
+}
diff --git a/calm-hub/src/main/java/org/finos/calm/store/mongo/MongoAdrStore.java b/calm-hub/src/main/java/org/finos/calm/store/mongo/MongoAdrStore.java
new file mode 100644
index 000000000..507194a52
--- /dev/null
+++ b/calm-hub/src/main/java/org/finos/calm/store/mongo/MongoAdrStore.java
@@ -0,0 +1,248 @@
+package org.finos.calm.store.mongo;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import com.mongodb.MongoWriteException;
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoDatabase;
+import com.mongodb.client.model.Filters;
+import com.mongodb.client.model.Projections;
+import com.mongodb.client.model.UpdateOptions;
+import com.mongodb.client.model.Updates;
+import jakarta.enterprise.context.ApplicationScoped;
+import org.bson.Document;
+import org.bson.conversions.Bson;
+import org.finos.calm.domain.adr.Adr;
+import org.finos.calm.domain.adr.AdrMeta;
+import org.finos.calm.domain.adr.AdrMetaBuilder;
+import org.finos.calm.domain.adr.AdrBuilder;
+import org.finos.calm.domain.adr.Status;
+import org.finos.calm.domain.exception.AdrNotFoundException;
+import org.finos.calm.domain.exception.AdrParseException;
+import org.finos.calm.domain.exception.AdrPersistenceException;
+import org.finos.calm.domain.exception.AdrRevisionNotFoundException;
+import org.finos.calm.domain.exception.NamespaceNotFoundException;
+import org.finos.calm.store.AdrStore;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+@ApplicationScoped
+public class MongoAdrStore implements AdrStore {
+
+    private final MongoCounterStore counterStore;
+    private final MongoNamespaceStore namespaceStore;
+    private final MongoCollection<Document> adrCollection;
+    private final ObjectMapper objectMapper;
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    public MongoAdrStore(MongoClient mongoClient, MongoCounterStore counterStore, MongoNamespaceStore namespaceStore) {
+        this.counterStore = counterStore;
+        this.namespaceStore = namespaceStore;
+        MongoDatabase database = mongoClient.getDatabase("calmSchemas");
+        this.adrCollection = database.getCollection("adrs");
+        this.objectMapper = new ObjectMapper();
+        objectMapper.registerModule(new JavaTimeModule());
+    }
+
+    @Override
+    public List<Integer> getAdrsForNamespace(String namespace) throws NamespaceNotFoundException {
+        if(!namespaceStore.namespaceExists(namespace)) {
+            throw new NamespaceNotFoundException();
+        }
+
+        Document namespaceDocument = adrCollection.find(Filters.eq("namespace", namespace)).first();
+
+        //protects from an unpopulated mongo collection
+        if(namespaceDocument == null || namespaceDocument.isEmpty()) {
+            return List.of();
+        }
+
+        List<Document> adrs = namespaceDocument.getList("adrs", Document.class);
+
+        return adrs.stream().map(adr -> adr.getInteger("adrId")).toList();
+    }
+
+    @Override
+    public AdrMeta createAdrForNamespace(AdrMeta adrMeta) throws NamespaceNotFoundException, AdrParseException {
+        if(!namespaceStore.namespaceExists(adrMeta.namespace())) {
+            throw new NamespaceNotFoundException();
+        }
+
+        String adrContentStr;
+        try {
+        adrContentStr = objectMapper.writeValueAsString(adrMeta.adrContent());
+        } catch(JsonProcessingException e) {
+            log.error("Could not write ADR Content to String", e);
+            throw new AdrParseException();
+        }
+
+        int id = counterStore.getNextAdrSequenceValue();
+        Document adrDocument = new Document("adrId", id).append("revisions",
+                new Document(String.valueOf(adrMeta.revision()), Document.parse(adrContentStr)));
+
+        adrCollection.updateOne(
+                Filters.eq("namespace", adrMeta.namespace()),
+                Updates.push("adrs", adrDocument),
+                new UpdateOptions().upsert(true));
+
+        return AdrMetaBuilder.builder(adrMeta).id(id).build();
+    }
+
+    @Override
+    public AdrMeta getAdr(AdrMeta adrMeta) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, AdrParseException {
+        Document adrDoc = retrieveAdrDoc(adrMeta);
+        return retrieveLatestRevision(adrMeta, adrDoc);
+    }
+
+    @Override
+    public List<Integer> getAdrRevisions(AdrMeta adrMeta) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException {
+        Document adrDoc = retrieveAdrDoc(adrMeta);
+        Document revisions = retrieveRevisionsDoc(adrDoc, adrMeta);
+        return revisions.keySet()
+                .stream()
+                .map(Integer::parseInt)
+                .toList();
+    }
+
+    @Override
+    public AdrMeta getAdrRevision(AdrMeta adrMeta) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, AdrParseException {
+        Document adrDoc = retrieveAdrDoc(adrMeta);
+        Document revisionsDoc = retrieveRevisionsDoc(adrDoc, adrMeta);
+
+        // Return the ADR JSON blob for the specified revision
+        Document revisionDoc = (Document) revisionsDoc.get(String.valueOf(adrMeta.revision()));
+        log.info("RevisionDoc: [{}], Revision: [{}]", adrDoc.get("revisions"), adrMeta.revision());
+        if(revisionDoc == null) {
+            throw new AdrRevisionNotFoundException();
+        }
+        try {
+            return AdrMetaBuilder.builder(adrMeta)
+                    .adrContent(objectMapper.readValue(revisionDoc.toJson(), Adr.class))
+                    .build();
+        } catch(JsonProcessingException e) {
+            log.error("Could not parse stored ADR to ADR Content.", e);
+            throw new AdrParseException();
+        }
+    }
+
+    @Override
+    public AdrMeta updateAdrForNamespace(AdrMeta adrMeta) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, AdrPersistenceException, AdrParseException {
+        Document adrDoc = retrieveAdrDoc(adrMeta);
+        AdrMeta latestRevision = retrieveLatestRevision(adrMeta, adrDoc);
+
+        int newRevision = latestRevision.revision() + 1;
+        AdrMeta newAdrMeta = AdrMetaBuilder.builder(adrMeta)
+                .adrContent(AdrBuilder.builder(adrMeta.adrContent())
+                        .status(latestRevision.adrContent().status())
+                        .creationDateTime(latestRevision.adrContent().creationDateTime())
+                        .build())
+                .revision(newRevision)
+                .build();
+
+        writeAdrToMongo(newAdrMeta);
+        return newAdrMeta;
+    }
+
+    @Override
+    public AdrMeta updateAdrStatus(AdrMeta adrMeta, Status status) throws AdrNotFoundException, NamespaceNotFoundException, AdrRevisionNotFoundException, AdrPersistenceException, AdrParseException {
+        Document adrDoc = retrieveAdrDoc(adrMeta);
+        AdrMeta latestRevision = retrieveLatestRevision(adrMeta, adrDoc);
+
+        int newRevisionNum = latestRevision.revision() + 1;
+        AdrMeta newRevision = AdrMetaBuilder.builder(latestRevision)
+                .revision(newRevisionNum)
+                .adrContent(AdrBuilder.builder(latestRevision.adrContent())
+                        .status(status)
+                        .build())
+                .build();
+        writeAdrToMongo(newRevision);
+        return newRevision;
+    }
+
+    private List<Document> retrieveAdrsDocs(String namespace) throws NamespaceNotFoundException, AdrNotFoundException {
+        if(!namespaceStore.namespaceExists(namespace)) {
+            throw new NamespaceNotFoundException();
+        }
+
+        Bson filter = new Document("namespace", namespace);
+        Bson projection = Projections.fields(Projections.include("adrs"));
+
+        Document result = adrCollection.find(filter).projection(projection).first();
+
+        if(result == null) {
+            throw new AdrNotFoundException();
+        }
+
+        return (List<Document>) result.get("adrs");
+    }
+
+    private Document retrieveAdrDoc(AdrMeta adrMeta) throws NamespaceNotFoundException, AdrNotFoundException {
+        List<Document> adrsDoc = retrieveAdrsDocs(adrMeta.namespace());
+        Optional<Document> adrOpt = adrsDoc.stream().filter(adrDoc -> adrMeta.id() == adrDoc.getInteger("adrId")).findAny();
+        return adrOpt.orElseThrow(AdrNotFoundException::new);
+    }
+
+    private Document retrieveRevisionsDoc(Document adrDoc, AdrMeta adrMeta) throws AdrRevisionNotFoundException {
+        Document revisionsDoc = (Document) adrDoc.get("revisions");
+
+        if(revisionsDoc == null || revisionsDoc.isEmpty()) {
+            log.error("Could not find the latest revision of ADR [{}]", adrMeta.id());
+            throw new AdrRevisionNotFoundException();
+        }
+
+        return revisionsDoc;
+    }
+
+    private AdrMeta retrieveLatestRevision(AdrMeta adrMeta, Document adrDoc) throws AdrRevisionNotFoundException, AdrParseException {
+        Document revisionsDoc = retrieveRevisionsDoc(adrDoc, adrMeta);
+
+        Set<String> revisionKeys = revisionsDoc.keySet();
+        int latestRevision = revisionKeys.stream()
+                .map(Integer::parseInt)
+                .mapToInt(i -> i)
+                .max()
+                .getAsInt();
+
+        // Return the ADR JSON blob for the specified revision
+        Document revisionDoc = (Document) revisionsDoc.get(String.valueOf(latestRevision));
+        log.info("RevisionDoc: [{}], Revision: [{}]", revisionDoc, latestRevision);
+        try {
+            return AdrMetaBuilder.builder()
+                    .namespace(adrMeta.namespace())
+                    .id(adrMeta.id())
+                    .revision(latestRevision)
+                    .adrContent(objectMapper.readValue(revisionDoc.toJson(), Adr.class))
+                    .build();
+        } catch(JsonProcessingException e) {
+            log.error("Could not parse stored ADR to ADR Content.", e);
+            throw new AdrParseException();
+        }
+    }
+
+    private void writeAdrToMongo(AdrMeta adrMeta) throws AdrPersistenceException, AdrParseException {
+
+        try {
+            Document adrDocument = Document.parse(objectMapper.writeValueAsString(adrMeta.adrContent()));
+            Document filter = new Document("namespace", adrMeta.namespace())
+                    .append("adrs.adrId", adrMeta.id());
+            Document update = new Document("$set",
+                    new Document("adrs.$.revisions." + adrMeta.revision(), adrDocument));
+
+            adrCollection.updateOne(filter, update, new UpdateOptions().upsert(true));
+
+        } catch(MongoWriteException ex) {
+            log.error("Failed to write ADR to mongo [{}]", adrMeta, ex);
+            throw new AdrPersistenceException();
+        } catch(JsonProcessingException e) {
+            log.error("Could not write ADR Content to String", e);
+            throw new AdrParseException();
+        }
+
+    }
+}
diff --git a/calm-hub/src/main/java/org/finos/calm/store/mongo/MongoCounterStore.java b/calm-hub/src/main/java/org/finos/calm/store/mongo/MongoCounterStore.java
index 24bc329a1..009e4f20a 100644
--- a/calm-hub/src/main/java/org/finos/calm/store/mongo/MongoCounterStore.java
+++ b/calm-hub/src/main/java/org/finos/calm/store/mongo/MongoCounterStore.java
@@ -26,6 +26,11 @@ public int getNextArchitectureSequenceValue() {
         return nextValueForCounter("architectureStoreCounter");
     }
 
+
+    public int getNextAdrSequenceValue() {
+        return nextValueForCounter("adrStoreCounter");
+    }
+
     public int getNextFlowSequenceValue() {
         return nextValueForCounter("flowStoreCounter");
     }
diff --git a/calm-hub/src/test/java/org/finos/calm/resources/TestAdrResourceShould.java b/calm-hub/src/test/java/org/finos/calm/resources/TestAdrResourceShould.java
new file mode 100644
index 000000000..d34b60ff1
--- /dev/null
+++ b/calm-hub/src/test/java/org/finos/calm/resources/TestAdrResourceShould.java
@@ -0,0 +1,388 @@
+package org.finos.calm.resources;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import io.quarkus.test.InjectMock;
+import io.quarkus.test.junit.QuarkusTest;
+import org.finos.calm.domain.adr.AdrMeta;
+import org.finos.calm.domain.adr.AdrMetaBuilder;
+import org.finos.calm.domain.adr.AdrBuilder;
+import org.finos.calm.domain.adr.Status;
+import org.finos.calm.domain.exception.AdrNotFoundException;
+import org.finos.calm.domain.exception.AdrParseException;
+import org.finos.calm.domain.exception.AdrPersistenceException;
+import org.finos.calm.domain.exception.AdrRevisionNotFoundException;
+import org.finos.calm.domain.exception.NamespaceNotFoundException;
+import org.finos.calm.store.AdrStore;
+import org.hamcrest.Matcher;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.time.LocalDateTime;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.nullValue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@QuarkusTest
+@ExtendWith(MockitoExtension.class)
+public class TestAdrResourceShould {
+
+    @InjectMock
+    AdrStore mockAdrStore;
+
+    @Test
+    void return_a_404_when_an_invalid_namespace_is_provided_on_get_adrs() throws NamespaceNotFoundException {
+        when(mockAdrStore.getAdrsForNamespace(anyString())).thenThrow(new NamespaceNotFoundException());
+
+        given()
+                .when()
+                .get("/calm/namespaces/invalid/adrs")
+                .then()
+                .statusCode(404);
+
+        verify(mockAdrStore, times(1)).getAdrsForNamespace("invalid");
+    }
+
+    @Test
+    void return_list_of_adr_ids_when_valid_namespace_provided_on_get_adrs() throws NamespaceNotFoundException {
+        when(mockAdrStore.getAdrsForNamespace(anyString())).thenReturn(Arrays.asList(12345, 54321));
+
+        given()
+                .when()
+                .get("/calm/namespaces/finos/adrs")
+                .then()
+                .statusCode(200)
+                .body(equalTo("{\"values\":[12345,54321]}"));
+
+        verify(mockAdrStore, times(1)).getAdrsForNamespace("finos");
+    }
+
+    static Stream<Arguments> provideParametersForCreateAdrTests() {
+        return Stream.of(
+                Arguments.of("invalid", new NamespaceNotFoundException(), 404, nullValue()),
+                Arguments.of("invalid", new AdrParseException(), 500, nullValue()),
+                Arguments.of("valid", null, 201, containsString("/calm/namespaces/valid/adrs/12/revisions/1"))
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideParametersForCreateAdrTests")
+    void respond_correctly_when_creating_adr(String namespace, Throwable exceptionToThrow, int expectedStatusCode, Matcher<?> locationHeader) throws NamespaceNotFoundException, AdrParseException {
+        if (exceptionToThrow != null) {
+            when(mockAdrStore.createAdrForNamespace(any(AdrMeta.class))).thenThrow(exceptionToThrow);
+        } else {
+            AdrMeta adrMeta = AdrMetaBuilder.builder()
+                    .adrContent(
+                            AdrBuilder.builder()
+                                    .title("My ADR")
+                                    .status(Status.draft)
+                                    .creationDateTime(LocalDateTime.now())
+                                    .updateDateTime(LocalDateTime.now())
+                                    .build()
+                    )
+                    .id(12)
+                    .revision(1)
+                    .namespace(namespace)
+                    .build();
+            when(mockAdrStore.createAdrForNamespace(any(AdrMeta.class))).thenReturn(adrMeta);
+        }
+
+        String adr = "{ \"title\": \"My ADR\" }";
+
+        given()
+                .header("Content-Type", "application/json")
+                .body(adr)
+                .when()
+                .post("/calm/namespaces/" + namespace +"/adrs")
+                .then()
+                .statusCode(expectedStatusCode)
+                .header("Location", locationHeader);
+
+        AdrMeta expectedAdrMeta = AdrMetaBuilder.builder()
+                .adrContent(
+                        AdrBuilder.builder()
+                                .title("My ADR")
+                                .status(Status.draft)
+                                .build())
+                .revision(1)
+                .namespace(namespace)
+                .build();
+
+        verify(mockAdrStore, times(1)).createAdrForNamespace(expectedAdrMeta);
+    }
+
+//    //Update ADR Tests
+
+    static Stream<Arguments> provideParametersForUpdateAdrTests() {
+        return Stream.of(
+                Arguments.of("invalid", new NamespaceNotFoundException(), 404),
+                Arguments.of("valid", new AdrNotFoundException(), 404),
+                Arguments.of("valid", new AdrRevisionNotFoundException(), 404),
+                Arguments.of("valid", new AdrParseException(), 500),
+                Arguments.of("valid", new AdrPersistenceException(), 500),
+                Arguments.of("valid", null, 201)
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideParametersForUpdateAdrTests")
+    void respond_correctly_to_update_adr(String namespace, Throwable exceptionToThrow, int expectedStatusCode) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, AdrPersistenceException, AdrParseException {
+        String adrJson = "{ \"title\": \"My ADR\" }";
+        if (exceptionToThrow != null) {
+            when(mockAdrStore.updateAdrForNamespace(any(AdrMeta.class))).thenThrow(exceptionToThrow);
+        } else {
+            AdrMeta adrMeta = AdrMetaBuilder.builder()
+                    .adrContent(
+                            AdrBuilder.builder()
+                                    .title("My ADR")
+                                    .status(Status.draft)
+                                    .creationDateTime(LocalDateTime.now())
+                                    .updateDateTime(LocalDateTime.now())
+                                    .build()
+                    )
+                    .id(1)
+                    .revision(2)
+                    .namespace(namespace)
+                    .build();
+            when(mockAdrStore.updateAdrForNamespace(any(AdrMeta.class))).thenReturn(adrMeta);
+        }
+
+        given()
+                .header("Content-Type", "application/json")
+                .body(adrJson)
+                .when()
+                .post("/calm/namespaces/" + namespace +"/adrs/1")
+                .then()
+                .statusCode(expectedStatusCode);
+
+        AdrMeta expectedAdrMeta = AdrMetaBuilder.builder()
+                .adrContent(
+                        AdrBuilder.builder()
+                                .title("My ADR")
+                                .build())
+                .id(1)
+                .namespace(namespace)
+                .build();
+
+        verify(mockAdrStore, times(1)).updateAdrForNamespace(expectedAdrMeta);
+    }
+
+    static Stream<Arguments> provideParametersForAdrRevisionTests() {
+        return Stream.of(
+                Arguments.of("invalid", new NamespaceNotFoundException(), 404),
+                Arguments.of("valid", new AdrNotFoundException(), 404),
+                Arguments.of("valid", new AdrRevisionNotFoundException(), 404),
+                Arguments.of("valid", null, 200)
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideParametersForAdrRevisionTests")
+    void respond_correctly_to_get_adr_revisions_query(String namespace, Throwable exceptionToThrow, int expectedStatusCode) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException {
+        var revisions = List.of(1, 2);
+        if (exceptionToThrow != null) {
+            when(mockAdrStore.getAdrRevisions(any(AdrMeta.class))).thenThrow(exceptionToThrow);
+        } else {
+            when(mockAdrStore.getAdrRevisions(any(AdrMeta.class))).thenReturn(revisions);
+        }
+
+        if (expectedStatusCode == 200 ) {
+            String expectedBody = "{\"values\":[1,2]}";
+            given()
+                    .when()
+                    .get("/calm/namespaces/" + namespace + "/adrs/12/revisions")
+                    .then()
+                    .statusCode(expectedStatusCode)
+                    .body(equalTo(expectedBody));
+        } else {
+            given()
+                    .when()
+                    .get("/calm/namespaces/" + namespace + "/adrs/12/revisions")
+                    .then()
+                    .statusCode(expectedStatusCode);
+        }
+
+        verifyExpectedAdrRevisions(namespace);
+    }
+
+    private void verifyExpectedAdrRevisions(String namespace) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException {
+        AdrMeta expectedAdrToRetrieveMeta = AdrMetaBuilder.builder()
+                .namespace(namespace)
+                .id(12)
+                .build();
+
+        verify(mockAdrStore, times(1)).getAdrRevisions(expectedAdrToRetrieveMeta);
+    }
+
+
+    static Stream<Arguments> provideParametersForGetAdrRevisionTests() {
+        return Stream.of(
+                Arguments.of("invalid", new NamespaceNotFoundException(), 404),
+                Arguments.of("valid", new AdrNotFoundException(), 404),
+                Arguments.of("valid", new AdrRevisionNotFoundException(), 404),
+                Arguments.of("valid", new AdrParseException(), 500),
+                Arguments.of("valid", null, 200)
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideParametersForGetAdrRevisionTests")
+    void respond_correctly_to_get_adr_revision(String namespace, Throwable exceptionToThrow, int expectedStatusCode) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, AdrParseException {
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(namespace)
+                .id(12)
+                .revision(1)
+                .adrContent(AdrBuilder.builder().title("My title").build())
+                .build();
+
+        if (exceptionToThrow != null) {
+            when(mockAdrStore.getAdrRevision(any(AdrMeta.class))).thenThrow(exceptionToThrow);
+        } else {
+            when(mockAdrStore.getAdrRevision(any(AdrMeta.class))).thenReturn(adrMeta);
+        }
+
+        if (expectedStatusCode == 200) {
+            AdrMeta actualAdrMeta = given()
+                    .when()
+                    .get("/calm/namespaces/" + namespace + "/adrs/12/revisions/1")
+                    .then()
+                    .statusCode(expectedStatusCode)
+                    .extract()
+                    .body()
+                    .as(AdrMeta.class);
+
+            assertEquals(adrMeta, actualAdrMeta);
+        } else {
+            given()
+                    .when()
+                    .get("/calm/namespaces/" + namespace + "/adrs/12/revisions/1")
+                    .then()
+                    .statusCode(expectedStatusCode);
+        }
+
+        verifyExpectedGetAdrRevision(namespace);
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideParametersForGetAdrRevisionTests")
+    void respond_correctly_to_get_adr(String namespace, Throwable exceptionToThrow, int expectedStatusCode) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, JsonProcessingException, AdrParseException {
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(namespace)
+                .id(12)
+                .revision(2)
+                .adrContent(AdrBuilder.builder().title("My title").build())
+                .build();
+
+        if (exceptionToThrow != null) {
+            when(mockAdrStore.getAdr(any(AdrMeta.class))).thenThrow(exceptionToThrow);
+        } else {
+            when(mockAdrStore.getAdr(any(AdrMeta.class))).thenReturn(adrMeta);
+        }
+
+        if (expectedStatusCode == 200) {
+            AdrMeta actualAdrMeta = given()
+                    .when()
+                    .get("/calm/namespaces/" + namespace + "/adrs/12")
+                    .then()
+                    .statusCode(expectedStatusCode)
+                    .extract()
+                    .body()
+                    .as(AdrMeta.class);
+            assertEquals(adrMeta, actualAdrMeta);
+        } else {
+            given()
+                    .when()
+                    .get("/calm/namespaces/" + namespace + "/adrs/12")
+                    .then()
+                    .statusCode(expectedStatusCode);
+        }
+
+        verifyExpectedGetAdr(namespace);
+    }
+
+    // Update ADR Status tests
+
+    static Stream<Arguments> provideParametersForUpdateAdrStatusTests() {
+        return Stream.of(
+                Arguments.of("invalid", new NamespaceNotFoundException(), 404),
+                Arguments.of("valid", new AdrNotFoundException(), 404),
+                Arguments.of("valid", new AdrRevisionNotFoundException(), 404),
+                Arguments.of("valid", new AdrParseException(), 500),
+                Arguments.of("valid", new AdrPersistenceException(), 500),
+                Arguments.of("valid", null, 201)
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideParametersForUpdateAdrStatusTests")
+    void respond_correctly_on_update_adr_status(String namespace, Throwable exceptionToThrow, int expectedStatusCode) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, AdrPersistenceException, AdrParseException {
+        String adrJson = "{ \"title\": \"My ADR\" }";
+        if (exceptionToThrow != null) {
+            when(mockAdrStore.updateAdrStatus(any(AdrMeta.class), any(Status.class))).thenThrow(exceptionToThrow);
+        } else {
+            AdrMeta adrMeta = AdrMetaBuilder.builder()
+                    .adrContent(
+                            AdrBuilder.builder()
+                                    .title("My ADR")
+                                    .status(Status.proposed)
+                                    .creationDateTime(LocalDateTime.now())
+                                    .updateDateTime(LocalDateTime.now())
+                                    .build()
+                    )
+                    .id(1)
+                    .revision(2)
+                    .namespace(namespace)
+                    .build();
+            when(mockAdrStore.updateAdrStatus(any(AdrMeta.class), any(Status.class))).thenReturn(adrMeta);
+        }
+
+        given()
+                .header("Content-Type", "application/json")
+                .body(adrJson)
+                .when()
+                .post("/calm/namespaces/" + namespace +"/adrs/1/status/proposed")
+                .then()
+                .statusCode(expectedStatusCode);
+
+        AdrMeta expectedAdrMeta = AdrMetaBuilder.builder()
+                .id(1)
+                .namespace(namespace)
+                .build();
+
+        verify(mockAdrStore, times(1)).updateAdrStatus(expectedAdrMeta, Status.proposed);
+    }
+
+    private void verifyExpectedGetAdrRevision(String namespace) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, AdrParseException {
+        AdrMeta expectedAdrToRetrieveMeta = AdrMetaBuilder.builder()
+                .namespace(namespace)
+                .id(12)
+                .revision(1)
+                .build();
+
+        verify(mockAdrStore, times(1)).getAdrRevision(expectedAdrToRetrieveMeta);
+    }
+
+    private void verifyExpectedGetAdr(String namespace) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, JsonProcessingException, AdrParseException {
+        AdrMeta expectedAdrToRetrieveMeta = AdrMetaBuilder.builder()
+                .namespace(namespace)
+                .id(12)
+                .build();
+
+        verify(mockAdrStore, times(1)).getAdr(expectedAdrToRetrieveMeta);
+    }
+
+}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoAdrStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoAdrStoreShould.java
new file mode 100644
index 000000000..0bf2a43d5
--- /dev/null
+++ b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoAdrStoreShould.java
@@ -0,0 +1,518 @@
+package org.finos.calm.store.mongo;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import com.mongodb.MongoWriteException;
+import com.mongodb.ServerAddress;
+import com.mongodb.WriteError;
+import com.mongodb.client.FindIterable;
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoDatabase;
+import com.mongodb.client.model.Filters;
+import com.mongodb.client.model.Projections;
+import com.mongodb.client.model.UpdateOptions;
+import com.mongodb.client.model.Updates;
+import io.quarkus.test.InjectMock;
+import io.quarkus.test.junit.QuarkusTest;
+import org.bson.BsonDocument;
+import org.bson.Document;
+import org.bson.conversions.Bson;
+import org.finos.calm.domain.adr.AdrMeta;
+import org.finos.calm.domain.adr.AdrMetaBuilder;
+import org.finos.calm.domain.adr.AdrBuilder;
+import org.finos.calm.domain.adr.Status;
+import org.finos.calm.domain.exception.AdrNotFoundException;
+import org.finos.calm.domain.exception.AdrParseException;
+import org.finos.calm.domain.exception.AdrPersistenceException;
+import org.finos.calm.domain.exception.AdrRevisionNotFoundException;
+import org.finos.calm.domain.exception.NamespaceNotFoundException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.empty;
+import static org.hamcrest.Matchers.is;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@QuarkusTest
+public class TestMongoAdrStoreShould {
+
+    @InjectMock
+    MongoClient mongoClient;
+
+    @InjectMock
+    MongoCounterStore counterStore;
+
+    @InjectMock
+    MongoNamespaceStore namespaceStore;
+
+    private ObjectMapper objectMapper;
+
+    private MongoDatabase mongoDatabase;
+    private MongoCollection<Document> adrCollection;
+    private MongoAdrStore mongoAdrStore;
+    private final String NAMESPACE = "finos";
+    private final AdrMeta simpleAdrMeta = AdrMetaBuilder.builder()
+            .namespace(NAMESPACE)
+            .id(42)
+            .revision(2)
+            .adrContent(AdrBuilder.builder()
+                    .title("My ADR")
+                    .status(Status.superseded)
+                    .creationDateTime(LocalDateTime.now())
+                    .updateDateTime(LocalDateTime.now())
+                    .build())
+            .build();
+
+    @BeforeEach
+    void setup() {
+        mongoDatabase = Mockito.mock(MongoDatabase.class);
+        adrCollection = Mockito.mock(MongoCollection.class);
+
+        when(mongoClient.getDatabase("calmSchemas")).thenReturn(mongoDatabase);
+        when(mongoDatabase.getCollection("adrs")).thenReturn(adrCollection);
+        mongoAdrStore = new MongoAdrStore(mongoClient, counterStore, namespaceStore);
+
+        this.objectMapper = new ObjectMapper();
+        objectMapper.registerModule(new JavaTimeModule());
+    }
+
+    @Test
+    void get_adrs_for_namespace_that_doesnt_exist_throws_exception() {
+        when(namespaceStore.namespaceExists(anyString())).thenReturn(false);
+        String namespace = "does-not-exist";
+
+        assertThrows(NamespaceNotFoundException.class,
+                () -> mongoAdrStore.getAdrsForNamespace(namespace));
+
+        verify(namespaceStore).namespaceExists(namespace);
+    }
+
+    @Test
+    void get_adrs_for_namespace_returns_empty_list_when_none_exist() throws NamespaceNotFoundException {
+        FindIterable<Document> findIterable = Mockito.mock(FindIterable.class);
+        when(namespaceStore.namespaceExists(anyString())).thenReturn(true);
+        when(adrCollection.find(eq(Filters.eq("namespace", NAMESPACE))))
+                .thenReturn(findIterable);
+        Document documentMock = Mockito.mock(Document.class);
+        when(findIterable.first()).thenReturn(documentMock);
+        when(documentMock.getList("adrs", Document.class))
+                .thenReturn(new ArrayList<>());
+
+        assertThat(mongoAdrStore.getAdrsForNamespace(NAMESPACE), is(empty()));
+        verify(namespaceStore).namespaceExists(NAMESPACE);
+    }
+
+    @Test
+    void get_adrs_for_namespace_returns_empty_list_when_mongo_collection_not_created() throws NamespaceNotFoundException {
+        FindIterable<Document> findIterable = Mockito.mock(FindIterable.class);
+        when(namespaceStore.namespaceExists(anyString())).thenReturn(true);
+        when(adrCollection.find(eq(Filters.eq("namespace", NAMESPACE))))
+                .thenReturn(findIterable);
+        when(findIterable.first()).thenReturn(null);
+
+        assertThat(mongoAdrStore.getAdrsForNamespace(NAMESPACE), is(empty()));
+        verify(namespaceStore).namespaceExists(NAMESPACE);
+    }
+
+    @Test
+    void get_adrs_for_namespace_returns_values() throws NamespaceNotFoundException {
+        FindIterable<Document> findIterable = Mockito.mock(FindIterable.class);
+        when(namespaceStore.namespaceExists(anyString())).thenReturn(true);
+        when(adrCollection.find(eq(Filters.eq("namespace", NAMESPACE))))
+                .thenReturn(findIterable);
+        Document documentMock = Mockito.mock(Document.class);
+        when(findIterable.first()).thenReturn(documentMock);
+
+        Document doc1 = new Document("adrId", 1001);
+        Document doc2 = new Document("adrId", 1002);
+
+        when(documentMock.getList("adrs", Document.class))
+                .thenReturn(Arrays.asList(doc1, doc2));
+
+        List<Integer> adrIds = mongoAdrStore.getAdrsForNamespace(NAMESPACE);
+
+        assertThat(adrIds, is(Arrays.asList(1001, 1002)));
+        verify(namespaceStore).namespaceExists(NAMESPACE);
+    }
+
+    @Test
+    void return_a_namespace_exception_when_namespace_does_not_exist_when_creating_an_adr() {
+        when(namespaceStore.namespaceExists(anyString())).thenReturn(false);
+        String namespace = "does-not-exist";
+        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(namespace).build();
+
+        assertThrows(NamespaceNotFoundException.class,
+                () -> mongoAdrStore.createAdrForNamespace(adrMeta));
+        verify(namespaceStore).namespaceExists(namespace);
+    }
+
+    @Test
+    void return_created_adr_when_parameters_are_valid() throws NamespaceNotFoundException, JsonProcessingException, AdrParseException {
+        String validNamespace = NAMESPACE;
+        int sequenceNumber = 42;
+        when(namespaceStore.namespaceExists(anyString())).thenReturn(true);
+        when(counterStore.getNextAdrSequenceValue()).thenReturn(sequenceNumber);
+        AdrMeta adrMetaToCreate = AdrMetaBuilder.builder()
+                .adrContent(AdrBuilder.builder().build())
+                .namespace(validNamespace)
+                .revision(1)
+                .build();
+
+        AdrMeta adrMeta = mongoAdrStore.createAdrForNamespace(adrMetaToCreate);
+
+        AdrMeta expectedAdrMeta = AdrMetaBuilder.builder()
+                .adrContent(AdrBuilder.builder().build())
+                .namespace(validNamespace)
+                .revision(1)
+                .id(sequenceNumber)
+                .build();
+
+        assertThat(adrMeta, is(expectedAdrMeta));
+        Document expectedDoc = new Document("adrId", adrMeta.id()).append("revisions",
+                new Document("1", Document.parse(objectMapper.writeValueAsString(adrMeta.adrContent()))));
+
+        verify(adrCollection).updateOne(
+                eq(Filters.eq("namespace", validNamespace)),
+                eq(Updates.push("adrs", expectedDoc)),
+                any(UpdateOptions.class));
+    }
+
+    @Test
+    void get_adr_revisions_for_invalid_namespace_throws_exception() {
+        when(namespaceStore.namespaceExists(anyString())).thenReturn(false);
+        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace("does-not-exist").build();
+
+        assertThrows(NamespaceNotFoundException.class,
+                () -> mongoAdrStore.getAdrRevisions(adrMeta));
+
+        verify(namespaceStore).namespaceExists(adrMeta.namespace());
+    }
+
+    private FindIterable<Document> setupInvalidAdr() {
+        FindIterable<Document> findIterable = Mockito.mock(FindIterable.class);
+        when(namespaceStore.namespaceExists(anyString())).thenReturn(true);
+        //Return the same find iterable as the projection unboxes, then return null
+        when(adrCollection.find(any(Bson.class)))
+                .thenReturn(findIterable);
+        when(findIterable.projection(any(Bson.class))).thenReturn(findIterable);
+        when(findIterable.first()).thenReturn(null);
+
+        return findIterable;
+    }
+
+    @Test
+    void get_adr_revisions_for_invalid_adr_throws_exception() {
+        FindIterable<Document> findIterable = setupInvalidAdr();
+        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE).build();
+
+        assertThrows(AdrNotFoundException.class,
+                () -> mongoAdrStore.getAdrRevisions(adrMeta));
+
+        verify(adrCollection).find(new Document("namespace", adrMeta.namespace()));
+        verify(findIterable).projection(Projections.fields(Projections.include("adrs")));
+    }
+
+    @Test
+    void get_adr_revisions_for_valid_adr_returns_list_of_revisions() throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, JsonProcessingException {
+        mockSetupAdrDocumentWithRevisions();
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE).id(42).build();
+        List<Integer> adrRevisions = mongoAdrStore.getAdrRevisions(adrMeta);
+
+        assertThat(adrRevisions, is(List.of(1)));
+    }
+
+    @Test
+    void get_adr_revision_for_invalid_namespace_throws_exception() {
+        when(namespaceStore.namespaceExists(anyString())).thenReturn(false);
+        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace("does-not-exist").build();
+
+        assertThrows(NamespaceNotFoundException.class,
+                () -> mongoAdrStore.getAdrRevision(adrMeta));
+
+        verify(namespaceStore).namespaceExists(adrMeta.namespace());
+    }
+
+    @Test
+    void throw_an_exception_for_an_invalid_adr_when_retrieving_adr_revision() {
+        FindIterable<Document> findIterable = setupInvalidAdr();
+        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE).build();
+
+        assertThrows(AdrNotFoundException.class,
+                () -> mongoAdrStore.getAdrRevision(adrMeta));
+
+        verify(adrCollection).find(new Document("namespace", adrMeta.namespace()));
+        verify(findIterable).projection(Projections.fields(Projections.include("adrs")));
+    }
+
+    @Test
+    void return_an_adr_revision() throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, AdrParseException, JsonProcessingException {
+        mockSetupAdrDocumentWithRevisions();
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE)
+                .id(42).revision(1).build();
+
+        AdrMeta adrMetaRevision = mongoAdrStore.getAdrRevision(adrMeta);
+        AdrMeta expectedAdrRevisionMeta = AdrMetaBuilder.builder(simpleAdrMeta).revision(1).build();
+        assertEquals(expectedAdrRevisionMeta, adrMetaRevision);
+    }
+
+    private void mockSetupAdrDocumentWithRevisions() throws JsonProcessingException {
+        Document mainDocument = setupAdrRevisionDocument();
+        FindIterable<Document> findIterable = Mockito.mock(FindIterable.class);
+        when(namespaceStore.namespaceExists(anyString())).thenReturn(true);
+        when(adrCollection.find(any(Bson.class)))
+                .thenReturn(findIterable);
+        when(findIterable.projection(any(Bson.class))).thenReturn(findIterable);
+        when(findIterable.first()).thenReturn(mainDocument);
+    }
+
+    private Document setupAdrRevisionDocument() throws JsonProcessingException {
+        //Set up an ADR document with 2 ADRs in (one with a valid revision)
+        Map<String, Document> revisionMap = new HashMap<>();
+        revisionMap.put("1", Document.parse(objectMapper.writeValueAsString(simpleAdrMeta.adrContent())));
+        Document targetStoredAdr = new Document("adrId", 42)
+                .append("revisions", new Document(revisionMap));
+
+        Document paddingAdr = new Document("adrId", 0);
+
+        return new Document("namespace", NAMESPACE)
+                .append("adrs", Arrays.asList(paddingAdr, targetStoredAdr));
+    }
+
+    @Test
+    void throw_an_exception_when_revision_of_adr_does_not_exist() throws JsonProcessingException {
+        mockSetupAdrDocumentWithRevisions();
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE)
+                .id(42).revision(9).build();
+
+        assertThrows(AdrRevisionNotFoundException.class,
+                () -> mongoAdrStore.getAdrRevision(adrMeta));
+    }
+
+    @Test
+    void throw_an_exception_when_no_revision_exists_when_getting_adr()  {
+        mockSetupAdrDocumentWithNoRevisions();
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE)
+                .id(42).revision(1).build();
+
+        assertThrows(AdrRevisionNotFoundException.class,
+                () -> mongoAdrStore.getAdr(adrMeta));
+    }
+
+    private Document setupAdrWithNoRevisions() {
+        //Set up an ADR document with 1 ADR with No Revisions
+
+        Document targetStoredAdr = new Document("adrId", 42);
+
+        return new Document("namespace", NAMESPACE)
+                .append("adrs", List.of(targetStoredAdr));
+    }
+
+    private void mockSetupAdrDocumentWithNoRevisions() {
+        Document mainDocument = setupAdrWithNoRevisions();
+        FindIterable<Document> findIterable = Mockito.mock(FindIterable.class);
+        when(namespaceStore.namespaceExists(anyString())).thenReturn(true);
+        when(adrCollection.find(any(Bson.class)))
+                .thenReturn(findIterable);
+        when(findIterable.projection(any(Bson.class))).thenReturn(findIterable);
+        when(findIterable.first()).thenReturn(mainDocument);
+    }
+
+    @Test
+    void throw_an_exception_for_an_invalid_adr_when_retrieving_adr() {
+        FindIterable<Document> findIterable = setupInvalidAdr();
+        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE).id(7).build();
+
+        assertThrows(AdrNotFoundException.class,
+                () -> mongoAdrStore.getAdr(adrMeta));
+
+        verify(adrCollection).find(new Document("namespace", adrMeta.namespace()));
+        verify(findIterable).projection(Projections.fields(Projections.include("adrs")));
+    }
+
+    @Test
+    void get_adr_for_invalid_namespace_throws_exception() {
+        when(namespaceStore.namespaceExists(anyString())).thenReturn(false);
+        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace("does-not-exist").build();
+
+        assertThrows(NamespaceNotFoundException.class,
+                () -> mongoAdrStore.getAdr(adrMeta));
+
+        verify(namespaceStore).namespaceExists(adrMeta.namespace());
+    }
+
+    @Test
+    void return_the_latest_adr_revision() throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, JsonProcessingException, AdrParseException {
+        mockSetupAdrDocumentWithRevisions();
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE)
+                .id(42).build();
+
+        AdrMeta latestAdrMeta = mongoAdrStore.getAdr(adrMeta);
+        AdrMeta expectedAdrMeta = AdrMetaBuilder.builder(simpleAdrMeta).revision(1).build();
+        assertEquals(expectedAdrMeta, latestAdrMeta);
+    }
+
+    @Test
+    void throw_an_exception_when_update_adr_with_a_namespace_that_doesnt_exists() {
+        when(namespaceStore.namespaceExists(anyString())).thenReturn(false);
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(NAMESPACE)
+                .id(42)
+                .build();
+
+        assertThrows(NamespaceNotFoundException.class,
+                () -> mongoAdrStore.updateAdrForNamespace(adrMeta));
+
+        verify(namespaceStore, times(1)).namespaceExists(adrMeta.namespace());
+    }
+
+    @Test
+    void throw_an_exception_when_updating_an_adr_that_doesnt_exist() throws JsonProcessingException {
+        mockSetupAdrDocumentWithRevisions();
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(NAMESPACE)
+                .id(22)
+                .build();
+
+        assertThrows(AdrNotFoundException.class,
+                () -> mongoAdrStore.updateAdrForNamespace(adrMeta));
+    }
+
+    @Test
+    void throw_an_exception_when_updating_an_adr_but_no_revisions_exist() {
+        mockSetupAdrDocumentWithNoRevisions();
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(NAMESPACE)
+                .id(42)
+                .adrContent(AdrBuilder.builder().build())
+                .build();
+
+        assertThrows(AdrRevisionNotFoundException.class,
+                () -> mongoAdrStore.updateAdrForNamespace(adrMeta));
+    }
+
+    @Test
+    void throw_an_exception_when_updating_an_adr_but_mongo_cannot_write_update() throws JsonProcessingException {
+        mockSetupAdrDocumentWithRevisions();
+        when(adrCollection.updateOne(any(Bson.class), any(Bson.class), any(UpdateOptions.class)))
+                .thenThrow(new MongoWriteException(new WriteError(1, "error", new BsonDocument()), new ServerAddress(), List.of()));
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(NAMESPACE)
+                .id(42)
+                .adrContent(AdrBuilder.builder().build())
+                .build();
+
+        assertThrows(AdrPersistenceException.class,
+                () -> mongoAdrStore.updateAdrForNamespace(adrMeta));
+    }
+
+    @Test
+    void return_successfully_when_correctly_updating_an_adr() throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, JsonProcessingException, AdrPersistenceException, AdrParseException {
+        mockSetupAdrDocumentWithRevisions();
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(NAMESPACE)
+                .id(42)
+                .revision(2)
+                .adrContent(AdrBuilder.builder().build())
+                .build();
+
+        mongoAdrStore.updateAdrForNamespace(adrMeta);
+
+        verify(adrCollection, times(1)).updateOne(any(Bson.class), any(Bson.class), any(UpdateOptions.class));
+    }
+
+    @Test
+    void throw_an_exception_when_updating_status_with_a_namespace_that_doesnt_exists() {
+        when(namespaceStore.namespaceExists(anyString())).thenReturn(false);
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(NAMESPACE)
+                .id(42)
+                .build();
+
+        assertThrows(NamespaceNotFoundException.class,
+                () -> mongoAdrStore.updateAdrStatus(adrMeta, Status.accepted));
+
+        verify(namespaceStore, times(1)).namespaceExists(adrMeta.namespace());
+    }
+
+    @Test
+    void throw_an_exception_when_updating_the_status_of_an_adr_that_doesnt_exist() throws JsonProcessingException {
+        mockSetupAdrDocumentWithRevisions();
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(NAMESPACE)
+                .id(22)
+                .build();
+
+        assertThrows(AdrNotFoundException.class,
+                () -> mongoAdrStore.updateAdrStatus(adrMeta, Status.accepted));
+    }
+
+    @Test
+    void throw_an_exception_when_updating_the_status_of_an_adr_but_no_revisions_exist() {
+        mockSetupAdrDocumentWithNoRevisions();
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(NAMESPACE)
+                .id(42)
+                .build();
+
+        assertThrows(AdrRevisionNotFoundException.class,
+                () -> mongoAdrStore.updateAdrStatus(adrMeta, Status.accepted));
+    }
+
+    @Test
+    void throw_an_exception_when_updating_the_status_of_an_adr_but_mongo_cannot_write_update() throws JsonProcessingException {
+        mockSetupAdrDocumentWithRevisions();
+        when(adrCollection.updateOne(any(Bson.class), any(Bson.class), any(UpdateOptions.class)))
+                .thenThrow(new MongoWriteException(new WriteError(1, "error", new BsonDocument()), new ServerAddress(), List.of()));
+
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(NAMESPACE)
+                .id(42)
+                .build();
+
+        assertThrows(AdrPersistenceException.class,
+                () -> mongoAdrStore.updateAdrStatus(adrMeta, Status.proposed));
+    }
+
+    @Test
+    void return_successfully_when_correctly_updating_the_status_of_an_adr() throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, JsonProcessingException, AdrPersistenceException, AdrParseException {
+        mockSetupAdrDocumentWithRevisions();
+        AdrMeta adrMeta = AdrMetaBuilder.builder()
+                .namespace(NAMESPACE)
+                .id(42)
+                .build();
+
+        mongoAdrStore.updateAdrStatus(adrMeta, Status.accepted);
+
+        verify(adrCollection, times(1)).updateOne(any(Bson.class), any(Bson.class), any(UpdateOptions.class));
+    }
+}