diff --git a/installers/charm/ro/src/charm.py b/installers/charm/ro/src/charm.py
new file mode 100755
index 0000000..8e6d576
--- /dev/null
+++ b/installers/charm/ro/src/charm.py
@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+# Copyright 2020 Canonical Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: legal@canonical.com
+#
+# To get in touch with the maintainers, please contact:
+# osm-charmers@lists.launchpad.net
+##
+
+import logging
+from typing import Dict, List, NoReturn
+
+from ops.charm import CharmBase
+from ops.framework import EventBase, StoredState
+from ops.main import main
+from ops.model import ActiveStatus, Application, BlockedStatus, MaintenanceStatus, Unit
+from oci_image import OCIImageResource, OCIImageResourceError
+
+from pod_spec import make_pod_spec
+
+logger = logging.getLogger(__name__)
+
+RO_PORT = 9090
+
+
+class RelationsMissing(Exception):
+    def __init__(self, missing_relations: List):
+        self.message = ""
+        if missing_relations and isinstance(missing_relations, list):
+            self.message += f'Waiting for {", ".join(missing_relations)} relation'
+            if "," in self.message:
+                self.message += "s"
+
+
+class RelationDefinition:
+    def __init__(self, relation_name: str, keys: List, source_type):
+        if source_type != Application and source_type != Unit:
+            raise TypeError(
+                "source_type should be ops.model.Application or ops.model.Unit"
+            )
+        self.relation_name = relation_name
+        self.keys = keys
+        self.source_type = source_type
+
+
+def check_missing_relation_data(
+    data: Dict,
+    expected_relations_data: List[RelationDefinition],
+):
+    missing_relations = []
+    for relation_data in expected_relations_data:
+        if not all(
+            f"{relation_data.relation_name}_{k}" in data for k in relation_data.keys
+        ):
+            missing_relations.append(relation_data.relation_name)
+    if missing_relations:
+        raise RelationsMissing(missing_relations)
+
+
+def get_relation_data(
+    charm: CharmBase,
+    relation_data: RelationDefinition,
+) -> Dict:
+    data = {}
+    relation = charm.model.get_relation(relation_data.relation_name)
+    if relation:
+        self_app_unit = (
+            charm.app if relation_data.source_type == Application else charm.unit
+        )
+        expected_type = relation_data.source_type
+        for app_unit in relation.data:
+            if app_unit != self_app_unit and isinstance(app_unit, expected_type):
+                if all(k in relation.data[app_unit] for k in relation_data.keys):
+                    for k in relation_data.keys:
+                        data[f"{relation_data.relation_name}_{k}"] = relation.data[
+                            app_unit
+                        ].get(k)
+                    break
+    return data
+
+
+class RoCharm(CharmBase):
+    """RO Charm."""
+
+    state = StoredState()
+
+    def __init__(self, *args) -> NoReturn:
+        """RO Charm constructor."""
+        super().__init__(*args)
+
+        # Internal state initialization
+        self.state.set_default(pod_spec=None)
+
+        self.port = RO_PORT
+        self.image = OCIImageResource(self, "image")
+
+        # Registering regular events
+        self.framework.observe(self.on.start, self.configure_pod)
+        self.framework.observe(self.on.config_changed, self.configure_pod)
+
+        # Registering required relation events
+        self.framework.observe(self.on.kafka_relation_changed, self.configure_pod)
+        self.framework.observe(self.on.mongodb_relation_changed, self.configure_pod)
+        self.framework.observe(self.on.mysql_relation_changed, self.configure_pod)
+
+        # Registering required relation departed events
+        self.framework.observe(self.on.kafka_relation_departed, self.configure_pod)
+        self.framework.observe(self.on.mongodb_relation_departed, self.configure_pod)
+        self.framework.observe(self.on.mysql_relation_departed, self.configure_pod)
+
+        # Registering required relation broken events
+        self.framework.observe(self.on.kafka_relation_broken, self.configure_pod)
+        self.framework.observe(self.on.mongodb_relation_broken, self.configure_pod)
+        self.framework.observe(self.on.mysql_relation_broken, self.configure_pod)
+
+        # Registering provided relation events
+        self.framework.observe(self.on.ro_relation_joined, self._publish_ro_info)
+
+    def _publish_ro_info(self, event: EventBase) -> NoReturn:
+        """Publishes RO information.
+
+        Args:
+            event (EventBase): RO relation event.
+        """
+        if self.unit.is_leader():
+            rel_data = {
+                "host": self.model.app.name,
+                "port": str(RO_PORT),
+            }
+            for k, v in rel_data.items():
+                event.relation.data[self.app][k] = v
+
+    @property
+    def relations_requirements(self):
+        if self.model.config["enable_ng_ro"]:
+            return [
+                RelationDefinition("kafka", ["host", "port"], Unit),
+                RelationDefinition("mongodb", ["connection_string"], Unit),
+            ]
+        else:
+            return [
+                RelationDefinition(
+                    "mysql", ["host", "port", "user", "password", "root_password"], Unit
+                )
+            ]
+
+    def get_relation_state(self):
+        relation_state = {}
+        for relation_requirements in self.relations_requirements:
+            data = get_relation_data(self, relation_requirements)
+            relation_state = {**relation_state, **data}
+        check_missing_relation_data(relation_state, self.relations_requirements)
+        return relation_state
+
+    def configure_pod(self, _=None) -> NoReturn:
+        """Assemble the pod spec and apply it, if possible.
+
+        Args:
+            event (EventBase): Hook or Relation event that started the
+                               function.
+        """
+        if not self.unit.is_leader():
+            self.unit.status = ActiveStatus("ready")
+            return
+
+        relation_state = None
+        try:
+            relation_state = self.get_relation_state()
+        except RelationsMissing as exc:
+            logger.exception("Relation missing error")
+            self.unit.status = BlockedStatus(exc.message)
+            return
+
+        self.unit.status = MaintenanceStatus("Assembling pod spec")
+
+        # Fetch image information
+        try:
+            self.unit.status = MaintenanceStatus("Fetching image information")
+            image_info = self.image.fetch()
+        except OCIImageResourceError:
+            self.unit.status = BlockedStatus("Error fetching image information")
+            return
+
+        try:
+            pod_spec = make_pod_spec(
+                image_info,
+                self.model.config,
+                relation_state,
+                self.model.app.name,
+                self.port,
+            )
+        except ValueError as exc:
+            logger.exception("Config/Relation data validation error")
+            self.unit.status = BlockedStatus(str(exc))
+            return
+
+        if self.state.pod_spec != pod_spec:
+            self.model.pod.set_spec(pod_spec)
+            self.state.pod_spec = pod_spec
+
+        self.unit.status = ActiveStatus("ready")
+
+
+if __name__ == "__main__":
+    main(RoCharm)
diff --git a/installers/charm/ro/src/pod_spec.py b/installers/charm/ro/src/pod_spec.py
new file mode 100644
index 0000000..b54710c
--- /dev/null
+++ b/installers/charm/ro/src/pod_spec.py
@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+# Copyright 2020 Canonical Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: legal@canonical.com
+#
+# To get in touch with the maintainers, please contact:
+# osm-charmers@lists.launchpad.net
+##
+
+import logging
+from typing import Any, Dict, List, NoReturn
+
+logger = logging.getLogger(__name__)
+
+
+def _validate_data(
+    config_data: Dict[str, Any], relation_data: Dict[str, Any]
+) -> NoReturn:
+    """Validates passed information.
+
+    Args:
+        config_data (Dict[str, Any]): configuration information.
+        relation_data (Dict[str, Any]): relation information
+
+    Raises:
+        ValueError: when config and/or relation data is not valid.
+    """
+    config_validators = {
+        "enable_ng_ro": lambda value, _: isinstance(value, bool),
+        "database_commonkey": lambda value, values: (
+            isinstance(value, str) and len(value) > 0
+        )
+        if values.get("enable_ng_ro", True)
+        else True,
+        "log_level": lambda value, _: isinstance(value, str)
+        and value in ("INFO", "DEBUG"),
+        "vim_database": lambda value, values: (
+            isinstance(value, str) and len(value) > 0
+        )
+        if not values.get("enable_ng_ro", True)
+        else True,
+        "ro_database": lambda value, values: (isinstance(value, str) and len(value) > 0)
+        if not values.get("enable_ng_ro", True)
+        else True,
+        "openmano_tenant": lambda value, values: (
+            isinstance(value, str) and len(value) > 0
+        )
+        if not values.get("enable_ng_ro", True)
+        else True,
+    }
+    relation_validators = {
+        "kafka_host": lambda value, _: (isinstance(value, str) and len(value) > 0)
+        if config_data.get("enable_ng_ro", True)
+        else True,
+        "kafka_port": lambda value, _: (isinstance(value, int) and value > 0)
+        if config_data.get("enable_ng_ro", True)
+        else True,
+        "mongodb_connection_string": lambda value, _: (
+            isinstance(value, str) and value.startswith("mongodb://")
+        )
+        if config_data.get("enable_ng_ro", True)
+        else True,
+        "mysql_host": lambda value, _: (isinstance(value, str) and len(value) > 0)
+        if not config_data.get("enable_ng_ro", True)
+        else True,
+        "mysql_port": lambda value, _: (isinstance(value, int) and value > 0)
+        if not config_data.get("enable_ng_ro", True)
+        else True,
+        "mysql_user": lambda value, _: (isinstance(value, str) and len(value) > 0)
+        if not config_data.get("enable_ng_ro", True)
+        else True,
+        "mysql_password": lambda value, _: (isinstance(value, str) and len(value) > 0)
+        if not config_data.get("enable_ng_ro", True)
+        else True,
+        "mysql_root_password": lambda value, _: (
+            isinstance(value, str) and len(value) > 0
+        )
+        if not config_data.get("enable_ng_ro", True)
+        else True,
+    }
+    problems = []
+
+    for key, validator in config_validators.items():
+        valid = validator(config_data.get(key), config_data)
+
+        if not valid:
+            problems.append(key)
+
+    for key, validator in relation_validators.items():
+        valid = validator(relation_data.get(key), relation_data)
+
+        if not valid:
+            problems.append(key)
+
+    if len(problems) > 0:
+        raise ValueError("Errors found in: {}".format(", ".join(problems)))
+
+
+def _make_pod_ports(port: int) -> List[Dict[str, Any]]:
+    """Generate pod ports details.
+
+    Args:
+        port (int): port to expose.
+
+    Returns:
+        List[Dict[str, Any]]: pod port details.
+    """
+    return [{"name": "ro", "containerPort": port, "protocol": "TCP"}]
+
+
+def _make_pod_envconfig(
+    config: Dict[str, Any], relation_state: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Generate pod environment configuration.
+
+    Args:
+        config (Dict[str, Any]): configuration information.
+        relation_state (Dict[str, Any]): relation state information.
+
+    Returns:
+        Dict[str, Any]: pod environment configuration.
+    """
+    envconfig = {
+        # General configuration
+        "OSMRO_LOG_LEVEL": config["log_level"],
+    }
+
+    if config.get("enable_ng_ro", True):
+        # Kafka configuration
+        envconfig["OSMRO_MESSAGE_DRIVER"] = "kafka"
+        envconfig["OSMRO_MESSAGE_HOST"] = relation_state["kafka_host"]
+        envconfig["OSMRO_MESSAGE_PORT"] = relation_state["kafka_port"]
+
+        # MongoDB configuration
+        envconfig["OSMRO_DATABASE_DRIVER"] = "mongo"
+        envconfig["OSMRO_DATABASE_URI"] = relation_state["mongodb_connection_string"]
+        envconfig["OSMRO_DATABASE_COMMONKEY"] = config["database_commonkey"]
+    else:
+        envconfig["RO_DB_HOST"] = relation_state["mysql_host"]
+        envconfig["RO_DB_OVIM_HOST"] = relation_state["mysql_host"]
+        envconfig["RO_DB_PORT"] = relation_state["mysql_port"]
+        envconfig["RO_DB_OVIM_PORT"] = relation_state["mysql_port"]
+        envconfig["RO_DB_USER"] = relation_state["mysql_user"]
+        envconfig["RO_DB_OVIM_USER"] = relation_state["mysql_user"]
+        envconfig["RO_DB_PASSWORD"] = relation_state["mysql_password"]
+        envconfig["RO_DB_OVIM_PASSWORD"] = relation_state["mysql_password"]
+        envconfig["RO_DB_ROOT_PASSWORD"] = relation_state["mysql_root_password"]
+        envconfig["RO_DB_OVIM_ROOT_PASSWORD"] = relation_state["mysql_root_password"]
+        envconfig["RO_DB_NAME"] = config["ro_database"]
+        envconfig["RO_DB_OVIM_NAME"] = config["vim_database"]
+        envconfig["OPENMANO_TENANT"] = config["openmano_tenant"]
+
+    return envconfig
+
+
+def _make_startup_probe() -> Dict[str, Any]:
+    """Generate startup probe.
+
+    Returns:
+        Dict[str, Any]: startup probe.
+    """
+    return {
+        "exec": {"command": ["/usr/bin/pgrep", "python3"]},
+        "initialDelaySeconds": 60,
+        "timeoutSeconds": 5,
+    }
+
+
+def _make_readiness_probe(port: int) -> Dict[str, Any]:
+    """Generate readiness probe.
+
+    Args:
+        port (int): service port.
+
+    Returns:
+        Dict[str, Any]: readiness probe.
+    """
+    return {
+        "httpGet": {
+            "path": "/openmano/tenants",
+            "port": port,
+        },
+        "periodSeconds": 10,
+        "timeoutSeconds": 5,
+        "successThreshold": 1,
+        "failureThreshold": 3,
+    }
+
+
+def _make_liveness_probe(port: int) -> Dict[str, Any]:
+    """Generate liveness probe.
+
+    Args:
+        port (int): service port.
+
+    Returns:
+        Dict[str, Any]: liveness probe.
+    """
+    return {
+        "httpGet": {
+            "path": "/openmano/tenants",
+            "port": port,
+        },
+        "initialDelaySeconds": 600,
+        "periodSeconds": 10,
+        "timeoutSeconds": 5,
+        "successThreshold": 1,
+        "failureThreshold": 3,
+    }
+
+
+def make_pod_spec(
+    image_info: Dict[str, str],
+    config: Dict[str, Any],
+    relation_state: Dict[str, Any],
+    app_name: str = "ro",
+    port: int = 9090,
+) -> Dict[str, Any]:
+    """Generate the pod spec information.
+
+    Args:
+        image_info (Dict[str, str]): Object provided by
+                                     OCIImageResource("image").fetch().
+        config (Dict[str, Any]): Configuration information.
+        relation_state (Dict[str, Any]): Relation state information.
+        app_name (str, optional): Application name. Defaults to "ro".
+        port (int, optional): Port for the container. Defaults to 9090.
+
+    Returns:
+        Dict[str, Any]: Pod spec dictionary for the charm.
+    """
+    if not image_info:
+        return None
+
+    _validate_data(config, relation_state)
+
+    ports = _make_pod_ports(port)
+    env_config = _make_pod_envconfig(config, relation_state)
+    startup_probe = _make_startup_probe()
+    readiness_probe = _make_readiness_probe(port)
+    liveness_probe = _make_liveness_probe(port)
+
+    return {
+        "version": 3,
+        "containers": [
+            {
+                "name": app_name,
+                "imageDetails": image_info,
+                "imagePullPolicy": "Always",
+                "ports": ports,
+                "envConfig": env_config,
+                "kubernetes": {
+                    "startupProbe": startup_probe,
+                    "readinessProbe": readiness_probe,
+                    "livenessProbe": liveness_probe,
+                },
+            }
+        ],
+        "kubernetesResources": {
+            "ingressResources": [],
+        },
+    }