How do you design and implement cloud-native application architectures?

Cloud-native architecture leverages cloud services for scalability, resilience, and operational efficiency. Core principles: microservices (independently deployable services), containers (Docker for packaging, Kubernetes for orchestration), serverless functions (event-driven compute without server management), and managed services (databases, message queues, caching as cloud services). Twelve-Factor App methodology: codebase in version control, explicit dependency declaration, configuration in environment variables, backing services as attached resources, strict separation of build/release/run stages, stateless processes, port binding for service exposure, concurrency through horizontal scaling, disposability with fast startup and graceful shutdown, dev/prod parity, logs as event streams, and admin processes as one-off tasks. Implementation: define service boundaries aligned with business domains, implement API-first design with OpenAPI specifications, use container orchestration (Kubernetes, ECS, Cloud Run) for deployment and scaling, and implement infrastructure as code (Terraform, Pulumi, CloudFormation) for reproducible environments. Networking: service mesh (Istio, Linkerd) for internal communication with mTLS, API gateway for external traffic, and CDN for static content and edge caching. Data: each service owns its database, implement event-driven communication for cross-service data needs, and use distributed caching (Redis, Memcached) for shared state. Observability: distributed tracing (Jaeger, Datadog APT), centralized logging (ELK, Grafana Loki), and metrics aggregation (Prometheus, CloudWatch). Cost optimization: implement auto-scaling based on metrics, use spot/preemptible instances for stateless workloads, right-size resources based on utilization data, and implement cost allocation tags for visibility.