diff --git a/swh/graphql/backends/archive.py b/swh/graphql/backends/archive.py
index c4f1dd8..5051ed8 100644
--- a/swh/graphql/backends/archive.py
+++ b/swh/graphql/backends/archive.py
@@ -1,37 +1,40 @@
 from swh.storage import get_storage
 
 
 class Archive:
     def __init__(self):
         # FIXME, setup config
         self.storage = get_storage(
             cls="remote", url="http://moma.internal.softwareheritage.org:5002"
         )
 
     def get_origin(self, url):
         return self.storage.origin_get([url])[0]
 
     def get_origins(self, after=None, first=50):
         return self.storage.origin_list(page_token=after, limit=first)
 
     def get_origin_visits(self, origin_url, after=None, first=50):
         return self.storage.origin_visit_get(origin_url, page_token=after, limit=first)
 
     def get_origin_visit(self, origin_url, visit_id):
         return self.storage.origin_visit_get_by(origin_url, visit_id)
 
     def get_visit_status(self, origin_url, visit_id, after=None, first=50):
         return self.storage.origin_visit_status_get(
             origin_url, visit_id, page_token=after, limit=first
         )
 
     def get_snapshot(self, snapshot_swhid):
         return self.storage.snapshot_get(snapshot_swhid)
 
     def get_snapshot_branches(self, snapshot, after=None, first=50):
         return self.storage.snapshot_get_branches(
             snapshot, branches_from=after, branches_count=first
         )
 
     def get_revision(self, revision_id):
         return self.storage.revision_get(revision_ids=[revision_id])
+
+    def get_release(self, release_id):
+        return self.storage.release_get(releases=[release_id])
diff --git a/swh/graphql/resolvers/release.py b/swh/graphql/resolvers/release.py
index eca22d1..ebfb36d 100644
--- a/swh/graphql/resolvers/release.py
+++ b/swh/graphql/resolvers/release.py
@@ -1,10 +1,25 @@
+from swh.graphql.backends import archive
+
 from .base_node import BaseNode
 
 
 class ReleaseNode(BaseNode):
     def _get_node_data(self):
-        # FIXME, make this call async (not for v1)
-        return {"rel": "test"}
+        """
+        """
+
+
+class BranchReleaseNode(BaseNode):
+    """
+    When the release is requested from
+    a snapshot branch
+    self.obj is a branch object
+    self.obj.target is the release id
+    """
+
+    def _get_node_data(self):
+        k = (archive.Archive().get_release(self.obj.target) or None)[0]
+        return k
 
     def is_type_of(self):
         return "Release"
diff --git a/swh/graphql/resolvers/resolver_factory.py b/swh/graphql/resolvers/resolver_factory.py
index 7ebf8ff..2b0e61d 100644
--- a/swh/graphql/resolvers/resolver_factory.py
+++ b/swh/graphql/resolvers/resolver_factory.py
@@ -1,46 +1,46 @@
 from .origin import OriginConnection, OriginNode
-from .release import ReleaseNode
+from .release import BranchReleaseNode  # , ReleaseNode
 from .revision import BranchRevisionNode  # , RevisionNode
 from .snapshot import SnapshotNode, VisitSnapshotNode
 from .snapshot_branch import SnapshotBranchConnection
 from .visit import OriginVisitConnection, OriginVisitNode
 from .visit_status import VisitStatusConnection
 
 # def get_mapping_key(info):
 #     """
 #     Logic to resolve mapping type
 #     """
 #     # FIXME, move to utils
 #     if info.path.prev:
 #         return f"{info.path.prev.key}_{info.path.key}"
 #     return info.path.key
 
 
 def get_node_resolver(resolver_type):
     # FIXME, replace with a proper factory method
     mapping = {
         "origin": OriginNode,
         "visit": OriginVisitNode,
         "visit-snapshot": VisitSnapshotNode,
         "snapshot": SnapshotNode,
         "branch-revision": BranchRevisionNode,
-        "branch-release": ReleaseNode,
+        "branch-release": BranchReleaseNode,
     }
     # resolver_type = get_mapping_key(info) # FIXME, get full name
     if resolver_type not in mapping:
         raise AttributeError(f"Invalid type request {resolver_type}")
     return mapping[resolver_type]
 
 
 def get_connection_resolver(resolver_type):
     # FIXME, replace with a proper factory method
     mapping = {
         "origins": OriginConnection,
         "origin-visits": OriginVisitConnection,
         "visit-status": VisitStatusConnection,
         "snapshot-branches": SnapshotBranchConnection,
     }
     # resolver_type = get_mapping_key(info) # FIXME, get full name
     if resolver_type not in mapping:
         raise AttributeError(f"Invalid type request {resolver_type}")
     return mapping[resolver_type]
diff --git a/swh/graphql/resolvers/revision.py b/swh/graphql/resolvers/revision.py
index 4911f7b..e0c7db4 100644
--- a/swh/graphql/resolvers/revision.py
+++ b/swh/graphql/resolvers/revision.py
@@ -1,42 +1,40 @@
 from swh.graphql.backends import archive
 
 from .base_node import BaseNode
 
 
 class RevisionNode(BaseNode):
     """
     When the revision is requested
     directly using an id
     """
 
     def _get_node_data(self):
         """
         """
 
 
 class BranchRevisionNode(BaseNode):
     """
     When the revision is requested from
     a snapshot branch
     self.obj is a branch object
     self.obj.target is the revision id
     """
 
     def _get_node_data(self):
         """
         self.obj.target is the Revision id
         """
         # FIXME, make this call async (not for v1)
-        # k = (archive.Archive().get_revision(self.obj.target) or None)[0]
-        # import pdb; pdb.set_trace()
         return (archive.Archive().get_revision(self.obj.target) or None)[0]
 
     def is_type_of(self):
         """
         is_type_of is required only when
         requesting from a connection
 
         This is for ariadne to return the correct type in schema
         """
         # FIXME, this is coupled with the schema
         return "Revision"
diff --git a/swh/graphql/schema/schema.graphql b/swh/graphql/schema/schema.graphql
index 303fd84..d501718 100644
--- a/swh/graphql/schema/schema.graphql
+++ b/swh/graphql/schema/schema.graphql
@@ -1,234 +1,237 @@
 scalar SWHId
 
 scalar DateTime
 
 scalar BinaryText
 
 interface Node {
   id: ID!
 }
 
 interface SWHNode {
   id: SWHId!
 }
 
 type PageInfo {
   endCursor: String
   hasNextPage: Boolean!
 }
 
 type OriginConnection {
   edges: [OriginEdge]
   nodes: [Origin]
   pageInfo: PageInfo!
   totalCount: Int
 }
 
 type OriginEdge {
   cursor: String!
   node: Origin
 }
 
 type Origin implements SWHNode {
   id: SWHId!  # FIXME, this is not swhid
   url: String!
   visits(
     first: Int
     after: String
   ): VisitConnection!
 }
 
 type VisitConnection {
   edges: [VisitEdge]
   nodes: [Visit]
   pageInfo: PageInfo!
   totalCount: Int
 }
 
 type VisitEdge {
   cursor: String!
   node: Visit
 }
 
 type Visit implements Node {
   id: ID!
   date: DateTime!
   type: String
   status(
     first: Int
     after: String
   ): VisitStatusConnection
   # origin: Origin # FIXME, this can be added later
 }
 
 type VisitStatusConnection {
   edges: [VisitStatusEdge]
   nodes: [VisitStatus]
   pageInfo: PageInfo!
   totalCount: Int
 }
 
 type VisitStatusEdge {
   cursor: String!
   node: VisitStatus
 }
 
 type VisitStatus implements Node {
   id: ID!
   status: String!
   date: DateTime!
   snapshot: Snapshot
   type: String
 }
 
 # FIXME, add OriginSnapshotConnection
 
 type Snapshot implements SWHNode {
   id: SWHId!
 
   branches(
     first: Int
     after: String
   ): BranchConnection
 
   # releases(
   #   first: Int
   #   after: String
   # ): ReleaseConnection
   # FIXME, add alias type as well
 }
 
 type BranchConnection {
   edges: [BranchConnectionEdge]
   nodes: [Branch]
   pageInfo: PageInfo!
   totalCount: Int
 }
 
 type BranchConnectionEdge {
   cursor: String!
   node: [Branch]
 }
 
 # FIXME, this could be alias or Directory as well
 union BranchTarget = Revision | Release
 
 type Branch implements Node {
   # FIXME, maybe implement Node is not needed here
   # As this has no independent existence
   id: ID!
   name: BinaryText
   type: String  # FIXME, change to an enum
   target: BranchTarget
 }
 
 # type RevisionConnection {
 # }
 
 # type RevisionEdge {
 # }
 
 type Person {
   email: BinaryText
   name: BinaryText
   fullname: BinaryText
 }
 
 type Revision implements SWHNode {
   id: SWHId!
   message: BinaryText
   author: Person
   committer: Person
   date: DateTime
   type: String
   directory: SWHId
 }
 
 # type ReleaseConnection {
 # }
 
 # type ReleasEdge {
 # }
 
 type Release implements SWHNode {
   id: SWHId!
-  rel: String
+  name: BinaryText
+  message: BinaryText
+  author: Person
+  date: DateTime
 }
 
 type Directory implements SWHNode {
   id: SWHId!
 }
 
 type Content implements SWHNode {
   id: SWHId!
 }
 
 type Query {
   """
   Get an origin with its url
   """
   # FIXME, find some unique id to help cache
   # maybe base64 encode the URL
   origin(
     url: String!
   ): Origin
 
   """
   Get a list of origins
   matching the given filters
   Can also be used to search for an origin
   """
   # FIMXE, use Input types to make this cleaner
   origins(
     first: Int
     after: String
   ): OriginConnection
 
   """
   Get a visit object with its id
   and/or origin and visit id
   """
   # FIXME, find some unique id to help cache
   visit(
     originUrl: String!
     id: String!
   ): Visit
 
   """
   Get a snapshot with SWHId
   """
   snapshot(
     SWHId: String!
   ): Snapshot
 
   # """
   # Get all the snapshot for the given origin
   # """
   # originSnapshot(
   #   originUrl: String!
   #   first: Int
   #   after: String
   # ): SnapshotConnection
 
   # """
   # Get the revision with the given swhid
   # """
   # revision()
 
   # """
   # Get the directory with the given swhid
   # """
   # directory
 
   # """
   # Get the content with the given swhid
   # """
   # content(
   #   SWHId: String!
   # ): Content
 
   # """
   # Search with the given swhid
   # """
   # searchWithSwhid
 }