Cloud native is an application development approach that uses technologies such as microservices, containers, container orchestrators and immutable infrastructure to build, deploy, run and manage responsive, scalable and fault-tolerant software applications in a cloud computing environment. Its Key Concepts:

Microservices: Applications are broken down into small, independent services that can be developed, deployed, and scaled independently. 
Containers: Applications and their dependencies are packaged into containers, ensuring consistent execution across different environments. 
Container Orchestration: Tools like Kubernetes manage and automate the deployment, scaling, and networking of containers. 
DevOps: Cloud-native development embraces DevOps practices, fostering collaboration between development and operations teams. 
CI/CD: Continuous integration and continuous delivery pipelines automate the build, test, and deployment process. 
Immutability: Cloud-native applications often use immutable infrastructure, meaning that once deployed, servers are not modified, and any changes involve creating new infrastructure. 
API-First Approach: Cloud-native applications are designed with APIs as a first-class citizen, enabling seamless integration with other services and applications. 

DevOps methodology is a set of cultural philosophies, practices, and tools that automate and integrate processes between software development and IT operations teams. It emphasizes collaboration, communication, and continuous integration/continuous delivery (CI/CD) to accelerate software delivery and improve reliability.

APIs are the backbone of modern software development. They enable diverse applications to communicate and share data seamlessly, making it possible to integrate different systems and services effectively. For any application, following good API design principles is crucial for creating robust, scalable, and user-friendly interfaces.

Applying SOLID principles provide guidelines and best practices for designing and writing robust and efficient code.

• Single Responsibility Principle (SRP)
• Open/Closed Principle (OCP)
• Liskov Substitution Principle (LSP)
• Interface Segregation Principle (ISP)
• Dependency Inversion Principle (DIP)

The twelve-factor app principles are a collection of best practices for building microservices-based cloud-native applications.

1. Codebase – One codebase tracked in revision control, many deploys
2. Dependencies – Explicitly declare and isolate dependencies
3. Configuration – Store configuration in the environment
4. Backing services – Treat backing services as attached resources
5. Build, release, run – Strictly separate build and run stages
6. Processes – Execute the app as one or more stateless processes
7. Port binding – Export services via port binding
8. Concurrency – Scale-out via the process model
9. Disposability – Maximize robustness with fast start-up and graceful shutdown
10. Dev/prod parity – Keep development, staging, and production as similar as possible
11. Logs – Treat logs as event streams
12. Admin processes – Run admin/management tasks as one-off processes					

DevSecOps brings an aspect of Security in every process cycle of development. It aims to build security into the software development lifecycle from the beginning, rather than as an afterthought. The intent of DevSecOps is to build on the mindset that "Everyone is responsible for Security."

Agile methodology is a project management approach focused on iterative development, flexibility, and collaboration. It breaks down projects into smaller, manageable cycles, allowing for continuous improvement and adaptation to change.

We also follow additional principles that contribute to code quality, maintainability, and longevity of projects.

• Don’t Repeat Yourself(DRY)
• Keep It Simple, Stupid(KISS)
• You Ain’t Gonna Need It(YAGNI)
• Convention over Configuration(CoC)
• Tell, Don’t Ask(TDA)