Skip to main content
Welcome back. In this lesson we’ll design and deploy a cloud-hosted application: a crypto coin website running on AWS. The primary challenge is scalability: the solution must enable rapid development, repeatable deployments, and the ability to grow seamlessly to handle variable traffic patterns. As the DevOps engineer, you’ll create a fast, automated development and deployment workflow that supports both front-end and back-end teams while ensuring production reliability and cost control.
The image shows a team structure for setting up a Crypto Coin website on AWS, highlighting frontend and backend developers, with a focus on addressing deployment challenges for scalability.
Can we achieve this? Absolutely. To build a solution that favors speed, automation, and scalability, we’ll map concrete AWS services and architectural patterns to developer needs. Below is a concise inventory of the primary AWS building blocks we’ll consider. Why choose AWS? It provides managed services and automation that speed development, offer built-in scalability (Auto Scaling, serverless), and optimize delivery through managed storage and global CDNs.
The image illustrates four benefits with icons: Speed, Scalability, Managed Databases, and Optimized Content Delivery.
Developers expect more than just hosting. Key functional requirements to address:
  • Rapid, iterative testing via staging environments, feature branches, and ephemeral preview environments for pull requests.
  • A reliable, automated CI/CD pipeline that supports frequent releases, health checks, rollbacks, and deployment strategies (blue/green, canary).
  • Predictable autoscaling and cost-awareness to handle traffic spikes without overspending.
  • Clear separation of concerns between the static front end and the API back end (single-page app served from S3/CloudFront vs. containerized or serverless API).
Design for environments: implement at least development, staging, and production pipelines. Use ephemeral preview environments for PR validation and automated integration tests to catch regressions before merge.
The image lists two developer requirements: setting up CI/CD for application deployment, and choosing scalability services for deployment.
Operational considerations (non-functional requirements) you should plan for:
  • Observability: centralized logging, metrics, distributed tracing, and alerts.
  • Security: least-privilege IAM roles, secrets management (AWS Secrets Manager or Parameter Store), TLS everywhere, and secure CI/CD credentials.
  • Cost optimization: right-size instances, use on-demand vs. spot where appropriate, and set up budgets and alerts.
  • Resilience: multi-AZ deployments, database backups/replication, and health-check-driven automated recovery.
Beware of runaway costs: aggressive autoscaling without proper scaling policies or missing resource cleanup for ephemeral environments can lead to unexpected charges. Implement budgets, alerts, and lifecycle policies.
Next steps
  1. Inspect the application repository to determine:
    • Is the frontend a static SPA or server-rendered?
    • Is the backend monolithic or split into microservices?
    • Database schema and expected traffic patterns.
  2. Map these findings to deployment patterns:
    • Static SPA → S3 + CloudFront + invalidation strategy.
    • Containerized API → ECS/Fargate or EKS with ALB and Auto Scaling.
    • Serverless endpoints → API Gateway + Lambda for low-management overhead.
  3. Define the CI/CD flow:
    • Build → test → deploy to ephemeral preview → promote to staging → smoke tests → promote to production.
    • Integrate automated rollback and health-check gating.
Links and references We’ll now locate and inspect the application codebase to make architecture decisions (monolith vs. microservices, static front end vs. API backend, database requirements) and map those choices to concrete AWS services and deployment flows.

Watch Video