diff --git a/docs/assets/images/CNCF_deploy.jpg b/docs/assets/images/CNCF_deploy.jpg
new file mode 100644
index 00000000..64b33254
Binary files /dev/null and b/docs/assets/images/CNCF_deploy.jpg differ
diff --git a/docs/assets/images/CNCF_develop.jpg b/docs/assets/images/CNCF_develop.jpg
new file mode 100644
index 00000000..149e2a70
Binary files /dev/null and b/docs/assets/images/CNCF_develop.jpg differ
diff --git a/docs/assets/images/CNCF_distribute.jpg b/docs/assets/images/CNCF_distribute.jpg
new file mode 100644
index 00000000..d3f54661
Binary files /dev/null and b/docs/assets/images/CNCF_distribute.jpg differ
diff --git a/docs/assets/images/CNCF_runtime.jpg b/docs/assets/images/CNCF_runtime.jpg
new file mode 100644
index 00000000..14fbb97d
Binary files /dev/null and b/docs/assets/images/CNCF_runtime.jpg differ
diff --git a/docs/security-introduction.md b/docs/security-introduction.md
new file mode 100644
index 00000000..a004b673
--- /dev/null
+++ b/docs/security-introduction.md
@@ -0,0 +1,61 @@
+# Genestack Secure Development Practices
+
+Genestack is a complete operation and deployment ecosystem for OpenStack services that hevily utilizes cloud native application like
+Kubernetes. While developing, publishing, deploying and running OpenStack services based on Genestack we aim to ensure that our engineering teams follow
+security best practices not just for OpenStack components but also for k8s and other cloud native applications used within the Genestack ecosystem.
+
+This security primer aims to outline layered security practices for Genestack, providing actionable security recommendations at every level to mitigate
+risks by securing infrastructure, platform, applications and data at each layer of the development process.
+This primer emphasizes secure development practices that complement Genestack's architecture and operational workflows.
+
+
+## Layered Security Approach
+
+Layered security ensures comprehensive protection against evolving threats by addressing risks at multiple levels. The approach applies security measures
+to both physical infrastructure and also provides security focus to the development of the application itself. The aim is to minimize a single point
+of failure compromising the entire system. This concept aligns with the cloud native environments by catagorizing security measures across the lifecycle and
+stack of the cloud native technologies.
+
+We aim to follow guidelines from CNCF that models cloud native application into distinct phases that constitute application lifecycle. Security is
+injected in each of these phases:
+
+1. **Develop:** Applying security principles during application development
+
+2. **Distribute:** Security practices to distribute code and artifacts
+
+3. **Deploy:** How to ensure security during application deployment
+
+4. **Runtime:** Best practices to secure infrastructure and interrelated components
+
+
+Lets look at it from OpenStack side of things. We want to see security across:
+
+1. **Infrastructure:** Both physical and virtual resources
+
+2. **Platform:** Services that support workloads
+
+3. **Applications:** Containerized workloads and instances that run the services
+
+4. **Data:** Security of data at rest and in transit
+
+
+CNCF defines its security principles as:
+
+1. Make security a design requirement
+
+2. Applying secure configuration has the best user experience
+
+3. Selecting insecure configuration is a conscious decision
+
+4. Transition from insecure to secure state is possible
+
+5. Secure defaults are inherited
+
+6. Exception lists have first class support
+
+7. Secure defaults protect against pervasive vulnerability exploits
+
+8. Security limitations of a system are explainable
+
+
+These guidelines can be adopted to have a secure foundation for Genestack based cloud.
diff --git a/docs/security-lifecycle.md b/docs/security-lifecycle.md
new file mode 100644
index 00000000..f3c03d03
--- /dev/null
+++ b/docs/security-lifecycle.md
@@ -0,0 +1,308 @@
+# Layered Security
+
+Layered security in cloud-native environments involves applying protection measures across all lifecycle stages: development, distribution, deployment, and runtime. Each stage incorporates specific controls to address security risks and maintain a robust defense. For example, during development, practices like secure coding and dependency scanning are emphasized. The distribution stage focuses on verifying artifacts, such as container images, with cryptographic signatures. Deployment involves infrastructure hardening and policy enforcement, ensuring secure configuration. Finally, runtime security includes monitoring and detecting anomalies, enforcing least privilege, and safeguarding active workloads to mitigate threats dynamically.
+
+Lets look at each stage in detail.
+
+## Develop
+
+The Develop phase in cloud-native security emphasizes integrating security into the early stages of application development. It involves secure coding practices, managing dependencies by scanning for vulnerabilities, and incorporating security testing into CI/CD pipelines. Developers adopt tools like static and dynamic analysis to identify risks in source code and applications. This proactive approach helps prevent vulnerabilities from progressing further down the lifecycle, reducing risks in later stages.
+
+
+ { width="700" height="400"}
+ Ref: CNCF Cloud Native Security Develop Phase
+
+
+
+=== "Infrastructure Layer"
+
+ * **CNCF Context**
+
+ Ensure infrastructure as code (IaC) is secure and scanned for vulnerabilities using tools like Checkov or Terraform Validator.
+
+ * **Recommendations**
+
+ Have separate development, staging and production environments.
+
+ Securely configure physical and virtual resources (e.g., OpenStack nodes, Kubernetes nodes) during the development of IaC templates.
+
+ Implement CI pipelines that test and validate infrastructure configurations against security benchmarks.
+
+
+=== "Platform Layer"
+
+ * **CNCF Context**
+
+ Harden platform components like OpenStack services or Kubernetes clusters in the configuration stage.
+
+ * **Recommendations**
+
+ Use security-focused configurations for platforms supporting workloads (e.g., hardened Helm charts, secured Nova and Neutron configurations).
+
+ Audit configuration files for misconfigurations using tools like kube-score.
+
+
+=== "Applications Layer"
+
+ * **CNCF Context**
+
+ Use secure coding practices and dependency scans to mitigate risks in application code.
+
+ * **Recommendations**
+
+ Ensure failures in CI is fixed and that tests exists for failure scenarios.
+
+ Develop application with 12 factor app concept.
+
+ Review code before merging. Follow pre-production and production branching.
+
+ Containerize workloads using scanned, validated images.
+
+ Integrate static application security testing (SAST) into CI pipelines.
+
+
+=== "Data Layer"
+
+ * **CNCF Context**
+
+ Secure sensitive data early by implementing encryption strategies.
+
+ * **Recommendations**
+
+ Ensure sensitive configuration data (e.g., Secrets, keys) is managed securely using Vault or Barbican.
+
+ Use tools like Snyk to scan code for data exposure risks.
+
+
+
+## Distribute
+
+The Distribute phase in cloud-native security focuses on ensuring that all software artifacts, such as container images and binaries, are securely handled during distribution. Key practices include signing artifacts with cryptographic signatures to verify their integrity and authenticity, scanning artifacts for vulnerabilities, and employing policies to prevent the distribution of untrusted or non-compliant components. A secure artifact registry, access controls, and monitoring of repository activity are essential to maintain trust and protect the supply chain. These measures help reduce risks of tampered or malicious artifacts being deployed in production environments.
+
+
+
+ { width="700" height="400"}
+ Ref: CNCF Cloud Native Security Distribute Phase
+
+
+
+=== "Infrastructure Layer"
+
+ * **CNCF Context**
+
+ Securely distribute infrastructure artifacts such as VM images or container runtimes.
+
+ * **Recommendations**
+
+ Build secure image building pipelines.
+
+ Use image signing (e.g., Sigstore, Notary) for OpenStack or Kubernetes.
+
+ Validate VM images against OpenStack Glance hardening guidelines.
+
+
+=== "Platform Layer"
+
+ * **CNCF Context**
+
+ Ensure platform components are securely distributed and deployed.
+
+ * **Recommendations**
+
+ Apply signed configuration files and use secure channels for distributing Helm charts.
+
+ Use integrity validation tools to verify signed manifests.
+
+ Use secure registry for container images.
+
+
+=== "Applications Layer"
+
+ * **CNCF Context**
+
+ Harden containers and validate their integrity before deployment.
+
+ * **Recommendations**
+
+ Leverage tools like Harbor to enforce vulnerability scans for container images.
+
+ Ensure SBOM (Software Bill of Materials) generation for all containerized workloads.
+
+ Cryptographically sign images.
+
+ Have container manifest scanning and hardening policies enforced.
+
+ Develop security tests for applications.
+
+
+=== "Data Layer"
+
+ * **CNCF Context**
+
+ Secure data movement and prevent exposure during distribution.
+
+ * **Recommendations**
+
+ Encrypt data at rest and enforce TLS for data in transit between distribution systems.
+
+ Periodically rotate encryption keys to ensure freshness.
+
+ Use secure container image registry with RABC policy.
+
+
+
+## Deploy
+
+The Deploy phase in cloud-native security focuses on securely setting up and configuring workloads and infrastructure in production environments. This phase emphasizes using tools like Infrastructure as Code (IaC) to define secure, consistent configurations. Security controls include enforcing policies such as mandatory access controls, network segmentation, and compliance with deployment best practices. Additionally, ensuring that only trusted artifacts, verified in the "Distribute" phase, are deployed is critical. Continuous validation of deployments and automated scanning help maintain security posture and prevent misconfigurations or vulnerabilities from affecting the runtime environment.
+
+
+ { width="700" height="400"}
+ Ref: CNCF Cloud Native Security Deploy Phase
+
+
+=== "Infrastructure Layer"
+
+ * **CNCF Context**
+
+ Use hardened deployment practices for nodes, ensuring compliance with security policies.
+
+ * **Recommendations**
+
+ Deploy OpenStack nodes and Kubernetes clusters with minimal services and secure configurations.
+
+ Automate security testing for production deployments.
+
+ Do pre-deploy infrastructure checks. (Example: host state, kerel version, patch status)
+
+ Setup secure log storage.
+
+
+=== "Platform Layer"
+
+ * **CNCF Context**
+
+ Secure APIs and runtime configurations for platforms.
+
+
+ * **Recommendations:**
+
+ Enable TLS for OpenStack APIs and enforce RBAC in Kubernetes clusters.
+
+ Use tools like OpenStack Security Groups and Kubernetes NetworkPolicies to isolate workloads.
+
+ Have strong observability and metrics for the platform.
+
+ Setup log aggregration.
+
+
+=== "Applications Layer"
+
+ * **CNCF Context:**
+
+ Apply runtime policies for containerized applications.
+
+ * **Recommendations:**
+
+ Enforce PodSecurity policies for Kubernetes workloads and hypervisor-level security for OpenStack instances.
+
+ Continuously monitor applications for compliance with runtime security policies.
+
+ Have a strong Incident Management policy.
+
+ Have a strong Alert/Event Management and Automation policy.
+
+
+=== "Data Layer"
+
+ * **CNCF Context:**
+
+ Protect sensitive data as it enters the runtime environment.
+
+ * **Recommendations:**
+
+ Encrypt data in transit using SSL/TLS and secure APIs with rate-limiting and authentication.
+
+ Perform regular audits of access logs for sensitive data.
+
+ Ensure data protection before deploy. (Example: make sure database backup exist)
+
+
+
+## Runtime
+
+The Runtime phase in cloud-native security focuses on protecting active workloads and infrastructure against threats while applications are operational. Key practices include continuous monitoring for anomalous behavior, enforcing runtime policies to restrict actions beyond predefined boundaries, and using tools like intrusion detection systems (IDS) and behavioral analytics. Securing runtime environments also involves employing least-privilege access controls, managing secrets securely, and isolating workloads to contain potential breaches. These proactive measures help maintain the integrity and confidentiality of applications in dynamic cloud-native ecosystems.
+
+
+ { width="700" height="400"}
+ Ref: CNCF Cloud Native Security Runtime Phase
+
+
+
+=== "Infrastructure Layer"
+
+ * **CNCF Context**
+
+ Monitor nodes for anomalies and ensure compliance with runtime configurations.
+
+
+ * **Recommendations**
+
+ Use tools like Prometheus and Falco to detect anomalies in OpenStack and Kubernetes nodes.
+
+ Automate incident response with tools like StackStorm.
+
+
+=== "Platform Layer"
+
+ * **CNCF Context**
+
+ Continuously secure platform services during operation.
+
+
+ * **Recommendations**
+
+ Apply monitoring tools to detect unusual API or service behaviors in OpenStack and Kubernetes.
+
+ Set up alerting for deviations in usage patterns or API calls.
+
+
+=== "Applications Layer"
+
+ * **CNCF Context**
+
+ Monitor containerized workloads for malicious or unexpected behavior.
+
+
+ * **Recommendations**
+
+ Use runtime security tools like Aqua Security or Sysdig to secure containerized applications.
+
+ Enforce network policies to restrict communication between workloads.
+
+
+=== "Data Layer"
+
+ * **CNCF Context**
+
+ Secure data throughout its lifecycle in runtime.
+
+
+ * **Recommendations**
+
+ Encrypt data streams and apply access controls to sensitive information.
+
+ Use backup solutions and test recovery mechanisms to ensure data availability.
+
+
+The Runtime phase encompasses several key components that form the foundation of a secure and highly available cloud environment. These components include:
+
+- Orchestration
+- Compute
+- Storage
+- Access Control
+
+Each of these components involves complex interdependencies and is critical to the stability and security of your cloud infrastructure. Ensuring their security not only requires adherence to best practices during the Develop, Distribute, and Deploy phases but also relies heavily on the overall cloud environment's design.
+
+## Building a Secure and Resilient Cloud Environment
+
+Our objective is to provide comprehensive guidelines for designing a secure and highly available cloud. Start by reviewing the recommendations outlined in our Cloud Design Documentation to understand best practices for structuring your cloud infrastructure. With this foundation, we can establish security principles tailored to each critical component, ensuring they are robust and resilient against potential threats.
diff --git a/docs/security-stages.md b/docs/security-stages.md
new file mode 100644
index 00000000..c289ad43
--- /dev/null
+++ b/docs/security-stages.md
@@ -0,0 +1,215 @@
+# Securing Private Cloud Infrastructure
+
+To ensure a secure and highly available cloud, the security framework must address orchestration, compute, storage, and access control in the context of a larger cloud design. This guide builds on a multi-layered, defense-in-depth approach, incorporating best practices across physical, network, platform, and application layers, aligned with a region -> multi-DC -> availability zone (AZ) design. Each component is discussed below with actionable strategies for robust protection.
+
+## Orchestration Security
+Orchestration platforms, such as OpenStack and Kubernetes, are fundamental to managing resources in a cloud environment. Securing these platforms ensures the stability and integrity of the overall cloud infrastructure. Below, we outline security considerations for both OpenStack and Kubernetes.
+
+#### Securing OpenStack
+OpenStack offers a robust framework for managing cloud resources, but its complexity requires careful security practices.
+
+- Implement software-defined networking (SDN) with micro-segmentation and zero-trust principles.
+- Leverage OpenStack Neutron for VXLAN/VLAN isolation, network function virtualization (NFV), and dynamic security group management.
+- Deploy next-generation firewalls (NGFWs) and intrusion prevention systems (IPS) to monitor and secure network traffic.
+- Use stateful packet inspection and machine learning-based anomaly detection to identify threats in real time.
+
+- Secure OpenStack Keystone with multi-factor authentication (MFA) and federated identity management (SAML, OAuth, or LDAP).
+- Enforce the principle of least privilege using RBAC and automated access reviews.
+
+- Integrate logs with a Security Information and Event Management (SIEM) system for real-time analysis.
+- Use machine learning-powered threat hunting and anomaly detection to enhance monitoring capabilities.
+
+#### Securing Kubernetes
+Kubernetes is widely used for container orchestration, and securing its components is essential for maintaining a resilient cloud environment.
+
+Pod Security Standards (PSS)
+
+- Adopt Kubernetes' Pod Security Standards, which define three security profiles:
+
+ - Privileged: Allows all pod configurations; use sparingly.
+ - Baseline: Enforces minimal restrictions for general-purpose workloads.
+ - Restricted: Applies the most stringent security controls, suitable for sensitive workloads.
+
+Pod Security Admission (PSA)
+
+- Enable Pod Security Admission to enforce Pod Security Standards dynamically.
+- Configure namespaces with PSA labels to define the allowed security profile for pods in that namespace (e.g., restricted or baseline).
+
+Service Account Security
+
+- Avoid default service accounts for workload pods.
+- Use Kubernetes RBAC to restrict the permissions of service accounts.
+- Rotate service account tokens regularly and implement short-lived tokens for increased security.
+
+Network Policies
+
+- Use Network Policies to define pod-to-pod communication and restrict access.
+- Allow only necessary traffic between services
+- Block external traffic to sensitive pods unless explicitly required.
+- Implement micro-segmentation within namespaces to isolate workloads.
+
+Kubernetes API Access
+
+- Restricting access to the control plane with network security groups.
+- Enabling RBAC for granular access control.
+- Securing API communication with mutual TLS and enforcing short-lived certificates.
+- Logging all API server requests for auditing purposes.
+
+
+## Compute Security
+Compute resources, including hypervisors and virtual machines (VMs), must be hardened to prevent unauthorized access and ensure isolation.
+
+#### Hypervisor and Host Security
+
+- Use hardware-assisted virtualization security features.
+- Enable Secure Boot, Trusted Platform Module (TPM), and kernel hardening (ASLR, DEP).
+- Leverage SELinux/AppArmor and hypervisor-level isolation techniques.
+- Use Intel SGX or AMD SEV for confidential computing.
+
+#### Virtual Machine Security
+
+- Perform image security scanning and mandatory signing.
+- Enforce runtime integrity monitoring and ephemeral disk encryption.
+- Ensure robust data-at-rest encryption via OpenStack Barbican.
+- Secure all communications with TLS and automate key management using HSMs.
+
+
+## Storage Security
+Protecting data integrity and availability across storage systems is vital for cloud resilience.
+
+- Encrypt data-at-rest and data-in-transit.
+- Implement automated key rotation and lifecycle management.
+- Use immutable backups and enable multi-region replication to protect against ransomware and data loss.
+- Establish encrypted, immutable backup systems.
+- Conduct regular RPO testing to validate recovery mechanisms.
+- Geographically distribute backups using redundant availability zones.
+
+
+## Access Control Security
+Access control ensures only authorized users and systems can interact with the cloud environment.
+
+- Implement multi-factor physical security mechanisms.
+- Biometric authentication and mantrap entry systems.
+- Maintain comprehensive access logs with timestamped and photographic records.
+- Redundant sensors for temperature, humidity, and fire.
+- UPS with automatic failover and geographically distributed backup generators.
+- Use IAM policies to manage user and system permissions.
+- Automate identity lifecycle processes and align access policies with regulatory standards.
+
+## Network and Infrastructure Security
+
+#### Network Segmentation and Isolation Network Design Principles
+
+Implement software-defined networking (SDN) with
+
+- Micro-segmentation Zero-trust network architecture Granular traffic control policies.
+- Use OpenStack Neutron advanced networking features.
+- VXLAN/VLAN isolation Network function virtualization (NFV) Dynamic security group management.
+- Deploy next-generation firewall (NGFW) solutions.
+- Implement intrusion detection/prevention systems (IDS/IPS).
+- Configure stateful packet inspection.
+- Utilize machine learning-based anomaly detection.
+
+
+## Larger Cloud Design: Integrating Region -> Multi-DC -> AZ Framework
+To enhance the security of orchestration, compute, storage, and access control components, the design must consider:
+
+- Regions: Isolate workloads geographically for regulatory compliance and disaster recovery.
+- Data Centers: Enforce physical security at each location and implement redundant power and environmental protection mechanisms.
+- Availability Zones (AZs): Segment workloads to ensure fault isolation and high availability.
+
+
+Effective OpenStack private cloud security requires a holistic, proactive approach. Continuous adaptation, rigorous implementation of multi-layered security controls, and commitment to emerging best practices are fundamental to maintaining a resilient cloud infrastructure. We can summarize the main cloud security principles in terms of the following:
+
+
+| **Pillar** | **Definition** | **Key Point(s)** |
+|---------------------|-------------------------------------------------------------------------------|----------------------------------------------------|
+| **Accountability** | Clear ownership and responsibility for securing cloud resources. | Track actions with detailed logs and use IAM tools.|
+| **Immutability** | Ensures resources are not altered post-deployment to preserve integrity. | Use immutable infrastructure and trusted pipelines.|
+| **Confidentiality** | Protects sensitive data from unauthorized access or exposure. | Encrypt data (e.g., TLS, AES) and enforce access control.|
+| **Availability** | Ensures resources are accessible when needed, even under stress. | Implement redundancy and DDoS protection. |
+| **Integrity** | Keeps systems and data unaltered except through authorized changes. | Verify with hashes and use version control. |
+| **Ephemerality** | Reduces exposure by frequently replacing or redeploying resources. | Use short-lived instances and rebase workloads regularly. |
+| **Resilience** | Builds systems that withstand and recover from failures or attacks. | Design for high availability and test disaster recovery. |
+| **Auditing and Monitoring** | Continuously observes environments for threats or violations. | Centralize logs and conduct regular security audits. |
+
+
+## Security Standards
+
+### NIST SP 800-53 (National Institute of Standards and Technology Special Publication 800-53)
+
+NIST SP 800-53 is a comprehensive catalog of security and privacy controls designed to protect federal information systems and organizations.
+It is widely adopted by public and private organizations to implement robust security frameworks.
+
+Main Focus Areas:
+
+- Access Control
+- Incidence Response
+- Risk assessment
+- Continuous monitoring
+
+### PCI DSS (Payment Card Industry Data Security Standard)
+
+PCI DSS is a security standard designed to ensure that organizations processing, storing, or transmitting credit card information maintain a secure environment.
+It is mandatory for entities handling payment card data.
+
+Main Focus Areas:
+
+- Secure Network Configurations
+- Encryption of Sensitive Data
+- Regular Monitoring and Testing
+- Strong Access Control Measures
+
+## ISO/IEC 27001 (International Organization for Standardization)
+
+ISO/IEC 27001 is a globally recognized standard for establishing, implementing, and maintaining an information security management system (ISMS).
+It helps organizations systematically manage sensitive information to keep it secure.
+
+Main Focus Areas:
+
+- Risk Management
+- Security Policies
+- Asset Management
+- Compliance and Audits
+
+## CIS Controls (Center for Internet Security)
+
+The CIS Controls are a prioritized set of actions to defend against the most common cyber threats.
+They provide actionable guidance for organizations of all sizes to enhance their security posture.
+
+Main Focus Areas:
+
+- Inventory and Control of Assets
+- Secure Configurations for Hardware and Software
+- Continuous Vulnerability Management
+- Data Protection
+
+## FedRAMP (Federal Risk and Authorization Management Program)
+
+FedRAMP is a U.S. federal program that provides a standardized approach to assessing, authorizing, and monitoring cloud service providers.
+It leverages NIST SP 800-53 as its foundation and ensures compliance for cloud services used by federal agencies.
+
+Main Focus Areas:
+
+- Security Assessments
+- Continuous Monitoring
+- Cloud Service Provider Authorization
+
+## GDPR (General Data Protection Regulation)
+
+GDPR is a European Union regulation focused on protecting personal data and ensuring privacy for EU citizens.
+It applies to all organizations processing or storing the personal data of individuals within the EU, regardless of location.
+
+Main Focus Areas:
+
+- Data Subject Rights (e.g., right to access, right to be forgotten)
+- Data Protection by Design and Default
+- Data Breach Notifications
+- Cross-Border Data Transfer Restrictions
+
+
+## Recommended References
+
+- OpenStack Security Guide
+- CIS OpenStack Benchmarks
+- SANS Cloud Security Best Practices
diff --git a/docs/security-summary.md b/docs/security-summary.md
new file mode 100644
index 00000000..7da01ec4
--- /dev/null
+++ b/docs/security-summary.md
@@ -0,0 +1,15 @@
+# Summary
+
+GeneStack's multi-region and hybrid design, leveraging OpenStack and Kubernetes, provides a robust foundation for cloud-native workloads. By integrating layered security practices, you can enhance resilience against evolving threats. Regular audits, continuous improvement, and adherence to cloud-native security principles are vital for maintaining a secure environment.
+
+Lets summarize our layered security approach in a table:
+
+| Lifecycle Phase | Infrastructure | Platform | Application | Data |
+| :---------: | :----------------------------------: | :-----------------------------------:| :-----------------------------:|:---------------------------------------:|
+| **Develop** | Secure IaC, Validate Nodes | Harden Platform Configs | Secure code, container images |Encrypt sensitive configuration and data |
+| **Distribute** | Validate Container/VM Images | Secure API and configuration delivery| Verify container integrity |Protect data during distribution |
+| **Deploy** | Handen Deployed Nodes | Enforce RBAC and security policies | Apply runtime policies |Encrypt data in transit |
+| **Runtime** | Monitor and Remediate Issues | Detect API issues and misuse | Monitor and secure workloads |Protect sensitive data streams |
+
+
+By integrating these practices our security approach ensures comprehensive protection across the entire lifecycle of Genestack based OpenStack cloud.
diff --git a/mkdocs.yml b/mkdocs.yml
index 824a8344..813a4ae6 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -292,5 +292,10 @@ nav:
- Openstack Volumes: openstack-volumes.md
- Openstack Load Balancers: openstack-load-balancer.md
- Openstack Networks: openstack-networks.md
+ - Security Primer:
+ - Introduction: security-introduction.md
+ - Security In Phases: security-lifecycle.md
+ - Cloud Security: security-stages.md
+ - Summary: security-summary.md
- Blog: https://blog.rackspacecloud.com/
- Status: api-status.md