Zachary Caudle

×

Secure & Scalable Portfolio Website (AWS) - V1

Legacy Architecture: This project demonstrates a full-stack skillset, from front-end development to advanced cloud infrastructure management on AWS using traditional 3-tier architecture.

AWS Services Used

• Amazon EC2: Provisioned a Linux virtual machine to host the web server
• Nginx: Configured an Nginx web server to serve the website content
• Application Load Balancer (ALB): Created a scalable, high-availability entry point
• AWS Certificate Manager (ACM): Provisioned SSL/TLS certificate for HTTPS
• Amazon Route 53: Configured DNS records for domain and email routing
• Amazon SES: Verified domain and set up email receiving system
• AWS Lambda: Deployed Python function for email forwarding
• Amazon S3: Stored incoming emails for Lambda processing

Skills Demonstrated

• Networking & Security configuration with security groups and load balancers
• Linux server administration with Nginx
• Load balancing and high availability implementation
• DNS management for domain and email routing
• Serverless computing with Lambda
• Systematic troubleshooting of complex cloud service interactions

Evolution Note

💡 This architecture was later refactored to a serverless model. See the "CloudCtzn Portfolio Refactor" project to learn how I optimized costs by 99% and eliminated operational overhead by migrating to S3 + CloudFront.

×

CloudCtzn Portfolio Refactor - V2

Summary: Refactoring a legacy EC2-based web server to a Serverless architecture to optimize cost and performance.

1. The Challenge (Situation)

My personal portfolio, CloudCtzn, was originally hosted on a traditional 3-tier architecture using an Amazon EC2 instance running a Linux web server behind an Application Load Balancer (ALB). While functional, this legacy architecture presented two major issues:

• High Cost: The idle compute resources (EC2) and load balancer fees resulted in a fixed cost of ~$30/month, regardless of traffic.
• Operational Overhead: The EC2 instance required regular OS patching, security updates, and maintenance.

2. The Solution (Action)

I engineered a migration plan to decouple the storage from the compute, moving to a fully Serverless Static Web Hosting model.

• Storage Layer: Migrated static assets (HTML/CSS/JS) to Amazon S3, utilizing standard storage classes for durability.
• Content Delivery: Implemented Amazon CloudFront as a global Content Delivery Network (CDN) to cache content at the edge, reducing latency for users worldwide.
• Security:
  • Configured Origin Access Control (OAC) to strictly limit S3 bucket access to the CloudFront distribution, effectively removing the bucket from the public internet.
  • Provisioned an SSL/TLS Certificate via AWS Certificate Manager (ACM) to enforce HTTPS encryption in transit.
• DNS: Reconfigured Amazon Route 53 using Alias records to point the apex domain (cloudctzn.com) and www subdomain directly to the CloudFront distribution.

3. The Outcome (Result)

• Cost Optimization: Reduced monthly operating costs by ~99%, moving from ~$30.00/month to less than $0.10/month (leveraging the S3 and CloudFront Free Tier).
• Performance: Improved page load speeds by serving content from AWS Edge Locations closest to the user.
• Security: Reduced the attack surface by eliminating the underlying Operating System (no SSH ports or unpatched vulnerabilities to manage).

Technologies Used

• AWS S3 (Object Storage)
• AWS CloudFront (CDN)
• AWS Route 53 (DNS Management)
• AWS Certificate Manager (SSL/TLS)
• Legacy Skill: Linux/EC2 Administration (Deprecated/Migrated)

Key Takeaway

✅ Lesson Learned: This migration demonstrates the importance of choosing the right architecture for the workload. While EC2 provided valuable learning experience with Linux administration and load balancing, serverless was the optimal solution for a static website with variable traffic patterns.

×

AWS Landing Zone Foundation

Built a secure, multi-account AWS environment that provides a scalable and governed foundation for deploying enterprise workloads using Terraform for Infrastructure as Code.

AWS Services Used

• AWS Organizations: Centrally managed multiple AWS accounts
• AWS IAM Identity Center: Centralized authentication and authorization
• Amazon S3: Secure, versioned storage for audit logs
• AWS CloudTrail: Comprehensive API activity logging and monitoring
• AWS Config: Continuous resource configuration auditing
• Service Control Policies (SCPs): Organizational security guardrails
• AWS KMS: Encryption key management for sensitive data
• Terraform: Complete infrastructure defined as code

Skills Demonstrated

• Enterprise cloud governance and security implementation
• Advanced Infrastructure as Code with Terraform
• Multi-account AWS architecture design
• Security best practices (SCPs, centralized logging, compliance monitoring)
• Scalable cloud foundation for enterprise workloads
• Understanding of large-scale cloud adoption challenges

×

AWS Zombie Hunter

Problem Statement: Zombie Assets are cloud resources that exist but aren't doing any work—they silently drain your budget.

Solution Overview

A Python-based automation script that connects to your AWS account, scans for unattached EBS volumes, and removes them safely to eliminate unnecessary storage costs.

Key Features

• Auto Discovery: Scans a specific AWS region for all EBS volumes
• Safety Switch: Includes a 'DRY_RUN' flag—if True, it only prints what would happen without making changes
• Race Condition Handling: Uses boto3.waiters to ensure volumes exist before deletion attempts, preventing errors
• Safe Execution: Built-in safeguards to prevent accidental deletion in production environments

Technologies Used

• Python 3.x: Core scripting language
• Boto3: AWS SDK for Python to interact with EC2 APIs
• AWS EC2: Target service for EBS volume management

Technical Implementation

• Leverages Boto3 EC2 client to describe and filter volumes
• Implements waiter patterns for asynchronous operation handling
• Uses error handling to gracefully manage API rate limits and permissions
• Configurable region-specific scanning for targeted cleanup

Skills Demonstrated

• FinOps methodology and cost optimization principles
• Python automation and scripting for cloud infrastructure
• AWS SDK (Boto3) proficiency
• Safe production operations with dry-run capabilities
• Understanding of EBS lifecycle management

×

AWS FinOps Toolkit

Mission: A collection of Python automation scripts designed to optimize AWS costs by identifying and cleaning up "Zombie Assets" (unused resources) and enforcing scheduling policies. Built using Boto3 and following FinOps methodology to reduce cloud waste.

Toolkit Components

1. Dev Instance Scheduler

Goal: Prevent non-production servers from running 24/7

• Logic: Scans for instances with the tag 'Environment: Dev'
• Action: Stops them immediately to save on compute costs
• Optimization: Uses server-side filtering at the API level to minimize data transfer and latency

2. EBS Snapshot Lifecycle Manager

Goal: Reduce storage costs by removing stale EBS snapshots

• Logic: Calculates the age of every snapshot owned by the account
• Action: Deletes snapshots older than 30 days (configurable retention period)
• Safety: Uses datetime math with UTC timezone awareness to ensure accuracy

3. Elastic IP Release Tool

Goal: Eliminate "hoarding penalties" for unattached static IPs

• Logic: Scans all Elastic IPs in the region
• Action: Identifies IPs that lack an AssociationId and releases them back to the AWS pool
• Cost Impact: Prevents charges for unused elastic IPs (~$3.60/month per IP)

Technologies Used

• Python 3.x: Core automation language
• Boto3: AWS SDK for Python
• AWS EC2 API: Instance management and EIP operations
• AWS EBS API: Snapshot lifecycle operations

Technical Highlights

• Server-Side Filtering: Reduces API data transfer by filtering at the AWS API level
• UTC Timezone Awareness: Ensures accurate datetime calculations across regions
• Idempotent Operations: Scripts can be run multiple times safely
• Configurable Parameters: Retention periods and filtering logic can be customized
• Error Handling: Graceful handling of API errors and permission issues

Skills Demonstrated

• FinOps principles and cost optimization strategies
• Python automation for cloud infrastructure management
• AWS Boto3 SDK advanced usage (filtering, pagination, waiters)
• Resource tagging strategies for governance
• Safe production operations with dry-run testing
• Understanding of AWS billing and cost drivers

Business Impact

This toolkit addresses common cloud cost waste scenarios:

• Reduces compute costs by stopping unused development instances
• Eliminates storage costs from forgotten snapshots
• Prevents elastic IP charges for unattached addresses
• Enables automated, repeatable cost optimization workflows

×

CloudCtzn Job Tracker

Problem Statement: Job seekers in today's market are applying to dozens of roles with no structured way to track where they are in each process. LinkedIn and Indeed send occasional email alerts but offer no real tracking tool.

Solution Overview

A full stack, containerized web application that lets users track job applications from submission to offer or rejection. Built from scratch and deployed to production on AWS with a fully automated CI/CD pipeline.

Key Features

• User Authentication: JWT-based auth with bcrypt password hashing
• Multi-tenant: Each user only sees their own data, enforced at the database query level
• Full CRUD: Add, view, update status, and delete job applications
• Persistent Storage: PostgreSQL database with Docker volumes surviving container restarts
• Auto Restart: systemd service ensures the app comes back up after server reboots

Architecture

• Frontend: HTML/CSS/JavaScript served by Flask
• Backend: Python Flask REST API with JWT protected routes
• Database: PostgreSQL running as a sidecar container via Docker Compose
• Hosting: AWS EC2 with Nginx as a reverse proxy and Let's Encrypt SSL
• Registry: AWS ECR for private Docker image storage
• CI/CD: GitHub Actions — push to main triggers build, push to ECR, and auto-deploy to EC2 via SSH
• DNS: Route 53 with Elastic IP for stable addressing

Technologies Used

• Docker & Docker Compose: Containerization and multi-container orchestration
• Python/Flask: Backend API and web serving
• PostgreSQL: Relational database with multi-tenant schema design
• GitHub Actions: CI/CD pipeline automation
• AWS ECR, EC2, Route 53: Cloud infrastructure
• Nginx: Reverse proxy and HTTPS termination
• bcrypt: Secure password hashing
• JWT: Stateless authentication

Skills Demonstrated

• Full stack application development
• Docker containerization and Docker Compose orchestration
• CI/CD pipeline design and implementation with GitHub Actions
• AWS infrastructure deployment and management
• Security best practices (bcrypt, JWT, HTTPS)
• Production deployment with auto-restart and persistent storage
• Multi-tenant database architecture