DEV Community: zach beecher

AWS resume challenge (cloud) 2025 indepth explanation

zach beecher — Fri, 15 Aug 2025 17:37:59 +0000

*If you didn't know what the challenge is, here it is in all its glory: https://cloudresumechallenge.dev/docs/the-challenge/aws/
*

I recommend building this out from scratch doing deep research on your own and struggle as that is how you'll learn, then coming back here to see the detailed approach to see how you did and what approach you took?

🌐 Frontend
Write your resume in HTML and style it with CSS
Host it as a static website on Amazon S3
Secure it with HTTPS via CloudFront
Point a custom domain to it using Route 53 or another DNS provider
🔢 Visitor Counter
Add a JavaScript-based counter to track site visits
Store the count in DynamoDB
Create a serverless API using API Gateway + AWS Lambda
Write the Lambda function in Python using the boto3 library
🔁 DevOps & Testing
Use Infrastructure as Code (like Terraform or CloudFormation)
Set up CI/CD pipelines with GitHub Actions
Write unit tests for your backend code

Week 1: Converted resume into HTML/CSS. Then I uploaded resume to a free tier S3 bucket. Bought domain name on namecheap ($1 dollar, what a deal), looking back should have used Route53 for 20 bucks instead. As the URL redirect on namecheap (DNS) isn't as robust as route53. Setup cloudfront for caching. Success - have resume on the aws web as static site on S3 bucket.

**Week 2: **JS based counter on website. Store the count in dynamoDB. Create serverless API using API gateway + Lambda. Write Python and use boto3 library for Lambda function.

Week 3: Devops time. github actions, setup a repo on gitup with CI/CD pipeline. Setup Unit tests for backend code.

Why do all this? Demonstrates real-world cloud skills

Covers key AWS services: S3, Lambda, DynamoDB, CloudFront, Route 53 (or any DNS), IAM

Builds a portfolio project that’s neat.

Helps prep for certifications like AWS Cloud Practitioner

Steps 1-3 easy parts -> HTML resume gpt can do this in 10 seconds -> host on s3 bucket aws (upload document). I'd recommend buying domain name on route53 service (20 us dollars) as going 3rd party creates more headaches like needing to generate a SSL certificate which can be tricky getting in a timely manner.

*Detailed steps below: *

Connecting an S3 Bucket to CloudFront for HTTPS
To enable HTTPS for your S3 website using CloudFront, follow these steps:

Prerequisites
An S3 bucket configured for static website hosting

Your website content uploaded to the bucket

Step-by-Step Configuration

Create a CloudFront Distribution Open the CloudFront console

Click "Create Distribution"

Under "Web", click "Get Started"

Configure Origin Settings Origin Domain Name: Select your S3 bucket from the dropdown (use the format bucket-name.s3.amazonaws.com for REST API endpoint)

Origin Path: Leave blank unless your content is in a subfolder

Origin ID: Automatically generated (you can customize if needed)

Restrict Bucket Access: Select "Yes" for better security

Origin Access Identity: Create a new OAI or use existing

Grant Read Permissions on Bucket: Select "Yes, Update Bucket Policy"

Configure Default Cache Behavior Settings Viewer Protocol Policy: Select "Redirect HTTP to HTTPS"

Allowed HTTP Methods: GET, HEAD (for static sites) or add others if needed

Cache Policy: Choose "CachingOptimized" for static content

Origin Request Policy: Leave as "None" for simple cases

Configure Distribution Settings Price Class: Choose based on your needs (e.g., "Use All Edge Locations")

Alternate Domain Names (CNAMEs): Enter your custom domain if you have one

SSL Certificate:

If using a custom domain, choose "Custom SSL Certificate" and select/request one from ACM

Otherwise, use "Default CloudFront Certificate"

Default Root Object: Enter "index.html" (or your default page)

Create the Distribution Click "Create Distribution"

Wait for deployment (this may take 10-40 minutes)

Update Your DNS (if using custom domain) Create a CNAME record pointing your domain to the CloudFront distribution domain (e.g., d111111abcdef8.cloudfront.net)

Important Notes:
After setup, access your site via the CloudFront URL (not the S3 URL) to benefit from HTTPS

If you previously used the S3 website endpoint (format: bucket-name.s3-website-region.amazonaws.com), you'll need to switch to the REST endpoint format for CloudFront

Clear cache in CloudFront if you update your content (or implement cache invalidation)

This setup provides HTTPS encryption, improved performance through caching, and better security by restricting direct access to your S3 bucket.

**now for the Javascript part 7:

Implementing a Visitor Counter with JavaScript for Your S3 Resume Website
Here's how to add a visitor counter to your static website hosted on S3 using JavaScript. Since S3 is static hosting (no server-side processing), we'll use a combination of JavaScript and AWS services to track visits.

Option 1: Simple Counter Using localStorage (Client-Side Only)
javascript
// visitor-counter.js
document.addEventListener('DOMContentLoaded', function() {
// Check if localStorage is available
if (typeof(Storage) !== "undefined") {
// Get or initialize the counter
let visitCount = localStorage.getItem('visitCount') || 0;

    // Increment the counter
    visitCount++;

    // Store the updated count
    localStorage.setItem('visitCount', visitCount);

    // Display the count
    document.getElementById('visitor-counter').textContent = 
        `You are visitor number ${visitCount}`;
} else {
    document.getElementById('visitor-counter').textContent = 
        "Visitor counter not available";
}

});
HTML:

html

Loading visitor count...

Limitation: This only tracks visits per browser/device.

Option 2: Using AWS Lambda + API Gateway + DynamoDB (More Accurate)
For a more accurate counter across all visitors:

Set up the backend: Create a DynamoDB table:

Table name: VisitorCounts

Primary key: pageId (string)

Create a Lambda function (Node.js):

javascript
// Lambda function to update and return visitor count
const AWS = require('aws-sdk');
const dynamo = new AWS.DynamoDB.DocumentClient();

exports.handler = async (event) => {
const pageId = 'resume-page'; // or your unique identifier

// Update the count
const updateParams = {
    TableName: 'VisitorCounts',
    Key: { pageId },
    UpdateExpression: 'ADD #count :incr',
    ExpressionAttributeNames: { '#count': 'count' },
    ExpressionAttributeValues: { ':incr': 1 },
    ReturnValues: 'UPDATED_NEW'
};

try {
    const result = await dynamo.update(updateParams).promise();
    return {
        statusCode: 200,
        body: JSON.stringify({ count: result.Attributes.count }),
        headers: { 'Access-Control-Allow-Origin': '*' }
    };
} catch (error) {
    return { statusCode: 500, body: JSON.stringify(error) };
}

};
Create API Gateway:

REST API

Create a GET method that triggers your Lambda

Enable CORS

Client-side JavaScript:
javascript
// visitor-counter.js
document.addEventListener('DOMContentLoaded', function() {
const counterElement = document.getElementById('visitor-counter');

// Replace with your API Gateway endpoint
const apiUrl = 'https://your-api-id.execute-api.region.amazonaws.com/prod/counter';

fetch(apiUrl)
.then(response => response.json())
.then(data => {
counterElement.textContent =
You are visitor number ${data.count};
})
.catch(error => {
console.error('Error fetching visitor count:', error);
counterElement.textContent = 'Visitor count not available';
});
});
HTML Implementation:
html

Loading visitor count...

Option 3: Using AWS CloudFront + Lambda@Edge
For a more advanced solution with better performance:

Create a Lambda@Edge function that triggers on viewer requests

The function would update DynamoDB with each visit

Inject the count into your page

Security Considerations:
For the API Gateway solution, consider adding rate limiting

For production use, you might want to implement some bot detection

The localStorage solution is simplest but least accurate

** step 8 now to setup dynamodb - aka database

Implementing a DynamoDB-Backed Visitor Counter for Your Resume Website
Let's set up a complete solution using DynamoDB to track visitors accurately. This approach will work with your S3-hosted static website and provide a persistent count across all visitors.

Step 1: Create the DynamoDB Table
Go to the DynamoDB console

Click "Create table"

Enter:

Table name: WebsiteVisitorCounts

Partition key: pageId (String)

Under "Table settings":

Select "Customize settings"

Capacity mode: "On-demand"

Click "Create table"

Step 2: Create a Lambda Function to Handle Counts
Go to the Lambda console

Click "Create function"

Select:

"Author from scratch"

Function name: updateVisitorCount

Runtime: Node.js (latest version)

Click "Create function"

Paste this code:

javascript
const AWS = require('aws-sdk');
const dynamodb = new AWS.DynamoDB.DocumentClient();
const TABLE_NAME = 'WebsiteVisitorCounts';

exports.handler = async (event) => {
const pageId = 'resume-homepage'; // Unique ID for your page

const params = {
    TableName: TABLE_NAME,
    Key: { pageId },
    UpdateExpression: 'SET #count = if_not_exists(#count, :start) + :incr',
    ExpressionAttributeNames: { '#count': 'count' },
    ExpressionAttributeValues: { ':incr': 1, ':start': 0 },
    ReturnValues: 'UPDATED_NEW'
};

try {
    const data = await dynamodb.update(params).promise();
    return {
        statusCode: 200,
        body: JSON.stringify({ count: data.Attributes.count }),
        headers: {
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Methods': 'GET, OPTIONS'
        }
    };
} catch (err) {
    console.error('Error:', err);
    return {
        statusCode: 500,
        body: JSON.stringify({ error: 'Could not update count' })
    };
}

};
Step 3: Set Up API Gateway
Go to API Gateway console

Click "Create API" > "REST API" > "Build"

Choose:

Protocol: REST

Create new API

API name: VisitorCounterAPI

Endpoint Type: Regional

Click "Create API"

Create a new resource:

Actions > Create Resource

Resource name: counter

Click "Create Resource"

Create a GET method:

Select the /counter resource

Actions > Create Method > GET

Integration type: Lambda Function

Check "Use Lambda Proxy integration"

Select your updateVisitorCount Lambda

Click "Save"

Enable CORS:

Select the /counter resource

Actions > Enable CORS

Keep default settings

Click "Enable CORS and replace existing CORS headers"

Deploy the API:

Actions > Deploy API

Deployment stage: [New Stage]

Stage name: prod

Click "Deploy"

Step 4: Update Your Website JavaScript
Add this to your HTML:

html

Loading visitor count...

Step 5: Set Up Permissions
Go to your Lambda function

Under "Configuration" > "Permissions"

Click the execution role name to edit in IAM

Add these permissions:

dynamodb:UpdateItem

dynamodb:GetItem

(Attach the AmazonDynamoDBFullAccess policy if you prefer)

Step 6: Initial Test
Manually add an initial record to DynamoDB:

Go to DynamoDB console

Select your table

Click "Create item"

Enter:

pageId: "resume-homepage"

count: 0 (Number)

Save

Cost Considerations
With on-demand DynamoDB:

You get 1 million read requests and 1 million write requests per month for free in AWS Free Tier

After that, $1.25 per million write requests and $0.25 per million read requests

For a personal resume site, you'll likely stay well within free tier limits

Advanced Options
Add caching: To reduce DynamoDB calls, you could:

Use localStorage to cache the count for returning visitors

Implement CloudFront caching for the API response

Enhance tracking: You could add:

Date-based tracking

Unique visitor detection (using cookies)

Geographic information

**APi time! Labnda get requests

Creating a Secure API for Your Visitor Counter Using API Gateway and Lambda
I'll guide you through setting up a proper API architecture that prevents direct database access from your frontend JavaScript. Here's the complete implementation:

Architecture Overview
text
[S3 Website] → [API Gateway] → [Lambda] → [DynamoDB]
Step 1: Create the Lambda Function
Go to the Lambda Console

Click "Create function"

Configure:

Function name: visitorCounterAPI

Runtime: Node.js 18.x

Architecture: x86_64

Click "Create function"

Paste this code:

javascript
const AWS = require('aws-sdk');
const dynamodb = new AWS.DynamoDB.DocumentClient();
const TABLE_NAME = process.env.TABLE_NAME || 'WebsiteVisitorCounts';

exports.handler = async (event) => {
// Validate HTTP method
if (event.httpMethod !== 'GET') {
return {
statusCode: 405,
body: JSON.stringify({ error: 'Method Not Allowed' }),
headers: { 'Access-Control-Allow-Origin': '*' }
};
}

const pageId = 'resume-homepage'; // Your unique identifier

try {
    // Atomic update of the counter
    const result = await dynamodb.update({
        TableName: TABLE_NAME,
        Key: { pageId },
        UpdateExpression: 'SET #count = if_not_exists(#count, :start) + :incr',
        ExpressionAttributeNames: { '#count': 'count' },
        ExpressionAttributeValues: { ':incr': 1, ':start': 0 },
        ReturnValues: 'UPDATED_NEW'
    }).promise();

    return {
        statusCode: 200,
        body: JSON.stringify({ 
            count: result.Attributes.count,
            timestamp: new Date().toISOString() 
        }),
        headers: { 
            'Access-Control-Allow-Origin': '*',
            'Content-Type': 'application/json'
        }
    };
} catch (error) {
    console.error('DynamoDB Error:', error);
    return {
        statusCode: 500,
        body: JSON.stringify({ error: 'Internal Server Error' }),
        headers: { 'Access-Control-Allow-Origin': '*' }
    };
}

};
Step 2: Configure API Gateway
Go to API Gateway Console

Create new HTTP API (not REST API for simpler CORS)

Click "Add integration"

Select Lambda

Choose your visitorCounterAPI function

API name: VisitorCounterAPI

Configure routes:

Path: /count

Method: GET

Click "Next" then "Create"

Step 3: Set Up CORS
In your API Gateway:

Select your API

Click "CORS" in the left menu

Configure:

Allow origins: * (or your specific domain)

Allow methods: GET

Allow headers: Content-Type

Click "Save"

Step 4: Set Up Lambda Permissions
Go to your Lambda function

Under "Configuration" > "Permissions"

Click the execution role name

Attach these policies:

AWSLambdaBasicExecutionRole

Create custom policy for DynamoDB access:

json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:UpdateItem",
"dynamodb:GetItem"
],
"Resource": "arn:aws:dynamodb:YOUR_REGION:YOUR_ACCOUNT_ID:table/WebsiteVisitorCounts"
}
]
}
Step 5: Implement Frontend JavaScript
javascript
// In your S3-hosted HTML file
async function updateVisitorCount() {
const counterElement = document.getElementById('visitor-counter');
if (!counterElement) return;

try {
    // Replace with your actual API Gateway endpoint
    const apiUrl = 'https://your-api-id.execute-api.region.amazonaws.com/count';

    const response = await fetch(apiUrl, {
        method: 'GET',
        headers: { 'Content-Type': 'application/json' }
    });

    if (!response.ok) throw new Error('Network response was not ok');

    const data = await response.json();
    counterElement.textContent = `Visitor Count: ${data.count}`;
} catch (error) {
    console.error('Error fetching visitor count:', error);
    counterElement.textContent = 'Visitor count unavailable';
}

}

// Call when page loads
document.addEventListener('DOMContentLoaded', updateVisitorCount);
Step 6: Deploy and Test
Deploy your API:

In API Gateway, select your API

Click "Deploy"

Create new stage (e.g., "prod")

Note the invoke URL

Test the endpoint:

bash
curl https://your-api-id.execute-api.region.amazonaws.com/prod/count
Check DynamoDB to verify the count is incrementing

Security Enhancements
Rate Limiting:

In API Gateway, create a usage plan

Set throttling to ~5 requests/second

API Keys (optional):

Create API key in API Gateway

Require key in your frontend requests

Input Validation:

The Lambda already validates it's a GET request

You could add more validation if needed

Cost Analysis
API Gateway: First 1 million requests/month are free ($1.00/million after)

Lambda: 1 million free requests/month ($0.20/million after)

DynamoDB: On-demand pricing, minimal cost for this use case

For a personal resume site, you'll likely stay well within free tier limits.

**Python time!

Implementing the Visitor Counter in Python with Lambda and Boto3
Let's rewrite the Lambda function in Python using the boto3 library for AWS operations. This will give you exposure to Python for backend development while maintaining all the security benefits of the API Gateway architecture.

Python Lambda Function Code
python
import json
import os
from datetime import datetime
import boto3

dynamodb = boto3.resource('dynamodb')
table_name = os.environ.get('TABLE_NAME', 'WebsiteVisitorCounts')
table = dynamodb.Table(table_name)

def lambda_handler(event, context):
# Validate HTTP method
if event['httpMethod'] != 'GET':
return {
'statusCode': 405,
'body': json.dumps({'error': 'Method Not Allowed'}),
'headers': {
'Content-Type': 'application/json',
'Access-Control-Allow-Origin': '*'
}
}

page_id = 'resume-homepage'  # Your unique identifier

try:
    # Atomic update of the counter
    response = table.update_item(
        Key={'pageId': page_id},
        UpdateExpression='SET #count = if_not_exists(#count, :start) + :incr',
        ExpressionAttributeNames={'#count': 'count'},
        ExpressionAttributeValues={':incr': 1, ':start': 0},
        ReturnValues='UPDATED_NEW'
    )

    return {
        'statusCode': 200,
        'body': json.dumps({
            'count': response['Attributes']['count'],
            'timestamp': datetime.utcnow().isoformat()
        }),
        'headers': {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*'
        }
    }

except Exception as e:
    print(f"Error updating DynamoDB: {str(e)}")
    return {
        'statusCode': 500,
        'body': json.dumps({'error': 'Internal Server Error'}),
        'headers': {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*'
        }
    }

Key Python Concepts Used
Boto3 Library: AWS's official Python SDK for interacting with AWS services

Environment Variables: Using os.environ for configuration

Error Handling: Python's try-except blocks

Dictionary Manipulation: Working with AWS response objects

JSON Handling: The json module for serialization

Deployment Steps
Create the Lambda Function:

Go to AWS Lambda Console

Click "Create function"

Select "Python 3.9" or later runtime

Name: pythonVisitorCounter

Upload the Code:

Paste the Python code above into the inline editor

Or package it as a ZIP file if you have dependencies

Set Environment Variable:

In Configuration → Environment variables

Add: TABLE_NAME = WebsiteVisitorCounts

Set Permissions:

Ensure the Lambda execution role has permissions to:

dynamodb:UpdateItem

dynamodb:GetItem

Attach the AmazonDynamoDBFullAccess policy if needed

Connect to API Gateway:

Use the same API Gateway setup as before

Just change the Lambda integration to point to your Python function

Python-Specific Benefits
Cleaner Syntax: Python's readability makes the code more maintainable

Strong Typing: Better error checking (especially with tools like mypy)

Rich Ecosystem: Access to Python's extensive libraries if you need to add functionality

Better Error Handling: More granular exception handling than JavaScript

Testing the Python Function
You can test locally before deploying:

Install Python 3.9+

Install dependencies:

bash
pip install boto3
Create a test event (save as test_event.json):

json
{
"httpMethod": "GET"
}
Test locally (with AWS credentials configured):

python
import lambda_function
print(lambda_function.lambda_handler({"httpMethod": "GET"}, None))
Cost Considerations
The Python implementation has the same cost profile as the JavaScript version:

First 1M Lambda requests free

Very minimal DynamoDB costs

API Gateway free tier covers typical personal site traffic

Next Steps
Consider adding input validation

Add logging with Python's logging module

Implement caching if needed

Set up monitoring with CloudWatch

**Tests time - unit tests / integration

Writing Tests for Your Python Lambda Function
Let's implement a comprehensive test suite for your visitor counter Lambda function using Python's built-in unittest framework. We'll test both the happy path and error scenarios.

Test Implementation
Create a new file named test_lambda_function.py with these tests:

python
import unittest
from unittest.mock import patch, MagicMock
import lambda_function
import json

class TestVisitorCounterLambda(unittest.TestCase):

def setUp(self):
    self.event = {
        'httpMethod': 'GET',
        'headers': {}
    }
    self.context = {}

@patch('lambda_function.dynamodb.Table')
def test_successful_count_update(self, mock_table):
    # Configure mock DynamoDB response
    mock_response = {
        'Attributes': {'count': 42},
        'ResponseMetadata': {'HTTPStatusCode': 200}
    }
    mock_table.return_value.update_item.return_value = mock_response

    # Call the function
    result = lambda_function.lambda_handler(self.event, self.context)

    # Verify results
    self.assertEqual(result['statusCode'], 200)
    response_body = json.loads(result['body'])
    self.assertEqual(response_body['count'], 42)
    self.assertIn('timestamp', response_body)
    self.assertEqual(result['headers']['Content-Type'], 'application/json')

    # Verify DynamoDB was called correctly
    mock_table.return_value.update_item.assert_called_once_with(
        Key={'pageId': 'resume-homepage'},
        UpdateExpression='SET #count = if_not_exists(#count, :start) + :incr',
        ExpressionAttributeNames={'#count': 'count'},
        ExpressionAttributeValues={':incr': 1, ':start': 0},
        ReturnValues='UPDATED_NEW'
    )

@patch('lambda_function.dynamodb.Table')
def test_wrong_http_method(self, mock_table):
    test_event = {'httpMethod': 'POST'}

    result = lambda_function.lambda_handler(test_event, self.context)

    self.assertEqual(result['statusCode'], 405)
    response_body = json.loads(result['body'])
    self.assertEqual(response_body['error'], 'Method Not Allowed')
    mock_table.return_value.update_item.assert_not_called()

@patch('lambda_function.dynamodb.Table')
def test_dynamodb_error_handling(self, mock_table):
    # Simulate DynamoDB error
    mock_table.return_value.update_item.side_effect = Exception('DB Error')

    result = lambda_function.lambda_handler(self.event, self.context)

    self.assertEqual(result['statusCode'], 500)
    response_body = json.loads(result['body'])
    self.assertEqual(response_body['error'], 'Internal Server Error')

@patch.dict('os.environ', {'TABLE_NAME': 'custom-table'})
@patch('lambda_function.dynamodb.Table')
def test_custom_table_name(self, mock_table):
    mock_response = {'Attributes': {'count': 1}}
    mock_table.return_value.update_item.return_value = mock_response

    lambda_function.lambda_handler(self.event, self.context)

    # Verify the custom table name was used
    mock_table.assert_called_once_with('custom-table')

if name == 'main':
unittest.main()
Key Testing Concepts Covered
Mocking AWS Services: Using unittest.mock to simulate DynamoDB

Happy Path Testing: Verifying successful counter increments

Error Scenarios: Testing wrong HTTP methods and database failures

Configuration Testing: Checking environment variable handling

Response Validation: Ensuring proper status codes and headers

Test Dependencies
Add these to a requirements-test.txt file:

text
boto3==1.26.*
moto==4.1.*
pytest==7.4.*
pytest-cov==4.1.*
Running the Tests
Install test dependencies:

bash
pip install -r requirements-test.txt
Run tests with unittest:

bash
python -m unittest test_lambda_function.py
Or with pytest (for more detailed output):

bash
pytest test_lambda_function.py -v
For coverage report:

bash
pytest --cov=lambda_function test_lambda_function.py
Advanced Testing Considerations
Integration Tests:

Deploy to a test AWS environment

Use actual API Gateway and DynamoDB resources

Test the full stack

Performance Tests:

Check Lambda cold start times

Verify DynamoDB latency

Security Tests:

Validate IAM permissions

Check for sensitive data exposure

Example Integration Test
python
import boto3
import os
import lambda_function

class TestIntegration(unittest.TestCase):
@classmethod
def setUpClass(cls):
# Set up real DynamoDB table (run once before all tests)
cls.dynamodb = boto3.resource('dynamodb')
cls.table_name = 'test-website-counts'
cls.table = cls.dynamodb.create_table(
TableName=cls.table_name,
KeySchema=[{'AttributeName': 'pageId', 'KeyType': 'HASH'}],
AttributeDefinitions=[{'AttributeName': 'pageId', 'AttributeType': 'S'}],
BillingMode='PAY_PER_REQUEST'
)
os.environ['TABLE_NAME'] = cls.table_name

def test_real_dynamodb_integration(self):
    # Initial test
    response1 = lambda_function.lambda_handler({'httpMethod': 'GET'}, None)
    self.assertEqual(response1['statusCode'], 200)

    # Verify increment works
    response2 = lambda_function.lambda_handler({'httpMethod': 'GET'}, None)
    count1 = json.loads(response1['body'])['count']
    count2 = json.loads(response2['body'])['count']
    self.assertEqual(count2, count1 + 1)

@classmethod
def tearDownClass(cls):
    # Clean up
    cls.table.delete()

Test Organization Best Practices
Keep unit tests fast and isolated

Put integration tests in separate files

Use mocking for AWS services in unit tests

Test both success and failure paths

Include edge cases (empty inputs, rate limits, etc.)

** IAC Infra as code - aka teraform

Implementing Infrastructure as Code with AWS SAM

Let's convert your entire visitor counter solution to Infrastructure as Code using AWS SAM (Serverless Application Model). This approach will make your infrastructure reproducible, version-controlled, and easily deployable.

AWS SAM Template (template.yaml)

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Visitor counter for resume website

Globals:
  Function:
    Timeout: 10
    Runtime: python3.9
    MemorySize: 128
    Environment:
      Variables:
        TABLE_NAME: !Ref VisitorCountTable

Resources:
  VisitorCounterFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: visitor_counter/
      Handler: lambda_function.lambda_handler
      Policies:
        - DynamoDBCrudPolicy:
            TableName: !Ref VisitorCountTable
      Events:
        ApiEvent:
          Type: Api
          Properties:
            Path: /count
            Method: GET
            RestApiId: !Ref VisitorCounterApi

  VisitorCounterApi:
    Type: AWS::Serverless::Api
    Properties:
      StageName: Prod
      Cors:
        AllowMethods: "'GET'"
        AllowOrigin: "'*'"
        AllowHeaders: "'Content-Type'"

  VisitorCountTable:
    Type: AWS::DynamoDB::Table
    Properties:
      TableName: WebsiteVisitorCounts
      AttributeDefinitions:
        - AttributeName: pageId
          AttributeType: S
      KeySchema:
        - AttributeName: pageId
          KeyType: HASH
      BillingMode: PAY_PER_REQUEST

Outputs:
  ApiEndpoint:
    Description: "API Gateway endpoint URL for Prod stage"
    Value: !Sub "https://${VisitorCounterApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/count"
  LambdaFunctionName:
    Description: "Visitor Counter Lambda Function Name"
    Value: !Ref VisitorCounterFunction

Project Structure

/resume-visitor-counter/
├── template.yaml            # SAM template
├── visitor_counter/
│   ├── lambda_function.py   # Lambda code
│   └── requirements.txt     # Python dependencies
├── tests/                   # Test files
└── README.md                # Deployment instructions

Lambda Function Code (visitor_counter/lambda_function.py)

import json
import os
from datetime import datetime
import boto3

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table(os.environ['TABLE_NAME'])

def lambda_handler(event, context):
    # API Gateway proxy events wrap the HTTP request
    http_method = event.get('httpMethod', '')

    if http_method != 'GET':
        return {
            'statusCode': 405,
            'body': json.dumps({'error': 'Method Not Allowed'}),
            'headers': {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*'
            }
        }

    page_id = 'resume-homepage'

    try:
        response = table.update_item(
            Key={'pageId': page_id},
            UpdateExpression='SET #count = if_not_exists(#count, :start) + :incr',
            ExpressionAttributeNames={'#count': 'count'},
            ExpressionAttributeValues={':incr': 1, ':start': 0},
            ReturnValues='UPDATED_NEW'
        )

        return {
            'statusCode': 200,
            'body': json.dumps({
                'count': response['Attributes']['count'],
                'timestamp': datetime.utcnow().isoformat()
            }),
            'headers': {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*'
            }
        }

    except Exception as e:
        print(f"Error updating DynamoDB: {str(e)}")
        return {
            'statusCode': 500,
            'body': json.dumps({'error': 'Internal Server Error'}),
            'headers': {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*'
            }
        }

Deployment Steps

Install AWS SAM CLI:

   pip install aws-sam-cli

Initialize Project (if starting from scratch):

   sam init --runtime python3.9 --app-template hello-world --name resume-visitor-counter

Build Application:

   sam build

Deploy to AWS:

   sam deploy --guided

Follow prompts to configure stack name, AWS region, etc.
Confirm deployment when prompted

View Outputs:

   aws cloudformation describe-stacks \
     --stack-name resume-visitor-counter \
     --query 'Stacks[0].Outputs'

Key Benefits of This Approach

Reproducibility: Entire infrastructure defined in code
Version Control: Track changes alongside application code
Easy Updates: Modify template and redeploy
Environment Parity: Same configuration across dev/test/prod
Rollback Capability: Revert to previous versions if needed

Advanced IaC Features

Parameters: Make configurations dynamic

   Parameters:
     TableName:
       Type: String
       Default: WebsiteVisitorCounts

Custom Domains: Add your own domain to API Gateway

   Domain:
     DomainName: api.yourdomain.com
     CertificateArn: !Ref SSLCertificate
     Route53:
       HostedZoneId: !Ref HostedZone

Multiple Environments: Use SAM with different configs

   sam deploy --config-env production

CI/CD Integration: Add to your deployment pipeline

   # Example GitHub Actions step
   - name: Deploy with SAM
     run: sam deploy --no-confirm-changeset
     env:
       AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
       AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}

Would you like me to show you how to add monitoring/alarms to this SAM template or demonstrate how to set up a CI/CD pipeline for automated deployments?

** source control - aka github version control etc

Setting Up CI/CD with GitHub Actions for Your Resume Website

Let's implement a complete CI/CD pipeline for both your frontend (S3 website) and backend (Lambda/DynamoDB/API Gateway) using GitHub Actions. This will automatically deploy changes whenever you push to your repository.

1. Repository Structure

resume-website/
├── backend/
│   ├── template.yaml       # SAM template
│   ├── lambda_function.py  # Lambda code
│   └── requirements.txt    # Python dependencies
├── frontend/
│   ├── index.html          # Your resume page
│   ├── styles.css          # CSS files
│   └── visitor-counter.js  # Frontend JavaScript
├── .github/
│   └── workflows/
│       ├── backend.yml     # Backend CI/CD workflow
│       └── frontend.yml    # Frontend CI/CD workflow
└── README.md

2. Backend CI/CD (GitHub Actions)

Create .github/workflows/backend.yml:

name: Backend Deployment

on:
  push:
    branches: [ main ]
    paths: 
      - 'backend/**'
      - '.github/workflows/backend.yml'

env:
  AWS_REGION: us-east-1
  STACK_NAME: resume-visitor-counter

jobs:
  deploy:
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: read

    steps:
      - name: Checkout repository
        uses: actions/checkout@v3

      - name: Configure AWS Credentials
        uses: aws-actions/configure-aws-credentials@v2
        with:
          role-to-assume: ${{ secrets.AWS_IAM_ROLE }}
          aws-region: ${{ env.AWS_REGION }}

      - name: Install SAM CLI
        run: pip install aws-sam-cli

      - name: Build SAM application
        working-directory: ./backend
        run: sam build

      - name: Deploy SAM application
        working-directory: ./backend
        run: sam deploy --no-confirm-changeset --no-fail-on-empty-changeset --stack-name ${{ env.STACK_NAME }} --region ${{ env.AWS_REGION }} --capabilities CAPABILITY_IAM

      - name: Get API endpoint
        id: api
        working-directory: ./backend
        run: |
          API_URL=$(aws cloudformation describe-stacks \
            --stack-name ${{ env.STACK_NAME }} \
            --query 'Stacks[0].Outputs[?OutputKey==`ApiEndpoint`].OutputValue' \
            --output text)
          echo "API_URL=$API_URL" >> $GITHUB_ENV
          echo "::set-output name=url::$API_URL"

      - name: Update frontend config
        if: always()
        run: |
          echo "VITE_API_URL=${{ env.API_URL }}" >> $GITHUB_ENV
          echo "API endpoint: ${{ env.API_URL }}"

3. Frontend CI/CD (GitHub Actions)

Create .github/workflows/frontend.yml:

name: Frontend Deployment

on:
  push:
    branches: [ main ]
    paths:
      - 'frontend/**'
      - '.github/workflows/frontend.yml'

env:
  AWS_REGION: us-east-1
  S3_BUCKET: your-resume-bucket-name
  CLOUDFRONT_DIST_ID: your-cloudfront-dist-id

jobs:
  deploy:
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: read

    steps:
      - name: Checkout repository
        uses: actions/checkout@v3

      - name: Configure AWS Credentials
        uses: aws-actions/configure-aws-credentials@v2
        with:
          role-to-assume: ${{ secrets.AWS_IAM_ROLE }}
          aws-region: ${{ env.AWS_REGION }}

      - name: Install dependencies
        working-directory: ./frontend
        run: npm install  # If using npm packages

      - name: Build static files
        working-directory: ./frontend
        run: |
          # Replace API endpoint in JavaScript
          if [ -n "${{ vars.API_URL }}" ]; then
            sed -i "s|const apiUrl = .*|const apiUrl = '${{ vars.API_URL }}';|" visitor-counter.js
          fi

      - name: Deploy to S3
        run: |
          aws s3 sync ./frontend s3://${{ env.S3_BUCKET }} --delete
          echo "Frontend deployed to: https://${{ env.S3_BUCKET }}.s3-website-${{ env.AWS_REGION }}.amazonaws.com"

      - name: Invalidate CloudFront cache
        run: |
          aws cloudfront create-invalidation \
            --distribution-id ${{ env.CLOUDFRONT_DIST_ID }} \
            --paths "/*"

4. Required GitHub Secrets

Set these in your GitHub repository settings (Settings > Secrets):

AWS_IAM_ROLE: ARN of IAM role for deployment (e.g., arn:aws:iam::123456789012:role/GitHubActionsRole)
AWS_REGION: Your AWS region (e.g., us-east-1)

5. AWS IAM Role Setup

Create an IAM role for GitHub Actions with these permissions:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "cloudformation:*",
        "lambda:*",
        "apigateway:*",
        "dynamodb:*",
        "s3:*",
        "cloudfront:*",
        "iam:*"
      ],
      "Resource": "*"
    }
  ]
}

6. Frontend JavaScript (visitor-counter.js)

Update to use the environment variable:

// Get API URL from build process
const apiUrl = process.env.VITE_API_URL || 'https://yourapi.execute-api.region.amazonaws.com/Prod/count';

document.addEventListener('DOMContentLoaded', function() {
    const counterElement = document.getElementById('visitor-counter');
    if (!counterElement) return;

    fetch(apiUrl)
        .then(response => response.json())
        .then(data => {
            counterElement.textContent = `Visitor Count: ${data.count}`;
        })
        .catch(error => {
            console.error('Error fetching visitor count:', error);
            counterElement.textContent = 'Visitor count unavailable';
        });
});

7. Workflow Improvements

Add Testing Stage:

   - name: Run Python tests
     working-directory: ./backend
     run: |
       pip install pytest
       python -m pytest tests/

Environment-Specific Deployments:

   strategy:
     matrix:
       environment: [dev, prod]

Manual Approval for Production:

   deploy-prod:
     needs: test
     runs-on: ubuntu-latest
     environment: production
     steps:
       - name: Wait for approval
         uses: trstringer/manual-approval@v1
         with:
           secret: ${{ github.token }}

Key Benefits

Automatic Deployments: Code changes trigger deployments
Consistency: Same process for all environments
Visibility: Clear deployment history in GitHub
Rollback Capability: Revert to previous commits if needed
Security: Least-privilege IAM roles

** github actions in depth

Backend CI/CD Pipeline with Testing and SAM Deployment

Here's a complete GitHub Actions workflow that will:

Run your Python tests on every push
Only deploy if tests pass
Package and deploy your SAM application to AWS

`.github/workflows/backend-ci-cd.yml`

name: Backend CI/CD Pipeline

on:
  push:
    branches: [ main ]
    paths:
      - 'backend/**'
      - '.github/workflows/backend-ci-cd.yml'

env:
  AWS_REGION: us-east-1
  STACK_NAME: resume-visitor-counter
  PYTHON_VERSION: '3.9'

jobs:
  test:
    name: Run Python Tests
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Set up Python ${{ env.PYTHON_VERSION }}
        uses: actions/setup-python@v4
        with:
          python-version: ${{ env.PYTHON_VERSION }}

      - name: Install dependencies
        working-directory: ./backend
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt
          pip install pytest boto3 moto

      - name: Run unit tests
        working-directory: ./backend
        run: |
          python -m pytest tests/ -v --cov=./ --cov-report=xml

      - name: Upload coverage report
        uses: codecov/codecov-action@v3
        with:
          file: ./backend/coverage.xml
          flags: unittests

  deploy:
    name: Deploy SAM Application
    needs: test
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: read

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v2
        with:
          role-to-assume: ${{ secrets.AWS_DEPLOY_ROLE }}
          aws-region: ${{ env.AWS_REGION }}

      - name: Install SAM CLI
        run: pip install aws-sam-cli

      - name: Build SAM application
        working-directory: ./backend
        run: sam build --use-container

      - name: Run SAM validate
        working-directory: ./backend
        run: sam validate

      - name: Deploy SAM application
        working-directory: ./backend
        run: |
          sam deploy \
            --no-confirm-changeset \
            --no-fail-on-empty-changeset \
            --stack-name ${{ env.STACK_NAME }} \
            --region ${{ env.AWS_REGION }} \
            --capabilities CAPABILITY_IAM \
            --resolve-s3

      - name: Output API endpoint
        working-directory: ./backend
        run: |
          echo "API Endpoint:"
          aws cloudformation describe-stacks \
            --stack-name ${{ env.STACK_NAME }} \
            --query "Stacks[0].Outputs[?OutputKey=='ApiEndpoint'].OutputValue" \
            --output text

Required Setup

AWS IAM Role:

Create a role with these permissions:

 {
   "Version": "2012-10-17",
   "Statement": [
     {
       "Effect": "Allow",
       "Action": [
         "cloudformation:*",
         "lambda:*",
         "apigateway:*",
         "dynamodb:*",
         "s3:*",
         "iam:PassRole"
       ],
       "Resource": "*"
     }
   ]
 }

Add the role ARN to GitHub Secrets as AWS_DEPLOY_ROLE

Backend Directory Structure:

   backend/
   ├── template.yaml
   ├── lambda_function.py
   ├── requirements.txt
   └── tests/
       ├── test_lambda.py
       └── __init__.py

requirements.txt:

   pytest==7.4.0
   pytest-cov==4.1.0
   moto==4.1.5
   boto3==1.26.118

Key Features

Test Isolation:
- Tests run in a separate job before deployment
- Deployment only proceeds if tests pass (needs: test)
Security:
- Uses AWS IAM Role for credentials (not access keys)
- Minimal required permissions
Validation:
- Runs sam validate to check template syntax
- Uses containerized builds for consistency
Visibility:
- Outputs API endpoint after deployment
- Generates code coverage reports
Optimizations:
- Caches Python dependencies between runs
- Uses --no-fail-on-empty-changeset to avoid failures when no changes detected

Advanced Options

Environment-Specific Deployments:

   strategy:
     matrix:
       environment: [dev, staging, prod]
       include:
         - environment: dev
           stack_name: resume-dev
         - environment: staging
           stack_name: resume-staging
         - environment: prod
           stack_name: resume-prod

Manual Approval for Production:

   deploy-prod:
     needs: test
     environment: production
     runs-on: ubuntu-latest
     steps:
       - name: Wait for approval
         uses: trstringer/manual-approval@v1
         with:
           secret: ${{ github.token }}
         if: github.ref == 'refs/heads/main'

Integration Tests:

   integration-test:
     needs: deploy
     runs-on: ubuntu-latest
     steps:
       - name: Run integration tests
         run: |
           pip install requests
           python -m pytest integration_tests/ -v

**CI CD pipelines.

Frontend CI/CD Pipeline for S3 and CloudFront

Here's a secure GitHub Actions workflow that will automatically deploy your frontend changes to S3 and invalidate the CloudFront cache without exposing any credentials.

`.github/workflows/frontend-ci-cd.yml`

name: Frontend CI/CD Pipeline

on:
  push:
    branches: [ main ]
    paths:
      - '**'
      - '!.github/workflows/backend-*.yml'  # Exclude backend workflows

env:
  AWS_REGION: us-east-1
  S3_BUCKET: your-resume-bucket-name
  CLOUDFRONT_DIST_ID: your-distribution-id

jobs:
  deploy:
    name: Deploy to S3 and Invalidate CloudFront
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: read

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v2
        with:
          role-to-assume: ${{ secrets.AWS_FRONTEND_DEPLOY_ROLE }}
          aws-region: ${{ env.AWS_REGION }}

      - name: Install dependencies (if using npm)
        run: npm ci
        if: exists('package.json')

      - name: Build project (if needed)
        run: npm run build
        if: exists('package.json')

      - name: Sync files to S3
        run: |
          aws s3 sync . s3://${{ env.S3_BUCKET }} \
            --delete \
            --exclude '.git/*' \
            --exclude '.github/*' \
            --exclude '*.yml' \
            --cache-control "max-age=31536000,public"  # Cache static assets

      - name: Create CloudFront invalidation
        run: |
          aws cloudfront create-invalidation \
            --distribution-id ${{ env.CLOUDFRONT_DIST_ID }} \
            --paths "/*"

      - name: Output website URL
        run: |
          echo "Website deployed to: https://$(aws cloudfront get-distribution \
            --id ${{ env.CLOUDFRONT_DIST_ID }} \
            --query 'Distribution.DomainName' \
            --output text)"

Required Setup

Create a dedicated IAM role for frontend deployments with these permissions:

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Action": [
           "s3:PutObject",
           "s3:GetObject",
           "s3:ListBucket",
           "s3:DeleteObject"
         ],
         "Resource": [
           "arn:aws:s3:::your-resume-bucket-name",
           "arn:aws:s3:::your-resume-bucket-name/*"
         ]
       },
       {
         "Effect": "Allow",
         "Action": [
           "cloudfront:CreateInvalidation",
           "cloudfront:GetDistribution"
         ],
         "Resource": "*"
       }
     ]
   }

Add these GitHub Secrets:
- AWS_FRONTEND_DEPLOY_ROLE: ARN of your IAM role
- CLOUDFRONT_DIST_ID: Your CloudFront distribution ID
- S3_BUCKET: Your S3 bucket name
Repository structure:

   frontend-repo/
   ├── index.html
   ├── styles/
   │   └── main.css
   ├── scripts/
   │   └── visitor-counter.js
   └── .github/
       └── workflows/
           └── frontend-ci-cd.yml

Security Best Practices

Never store credentials in code - Use GitHub Secrets and IAM roles
Least privilege principle - Only grant required S3/CloudFront permissions
Exclude sensitive files - The workflow excludes .git/ and .github/ from sync
Use OIDC - GitHub's OpenID Connect for temporary credentials

Advanced Configuration Options

Environment-specific deployments:

   strategy:
     matrix:
       environment: [staging, prod]
       include:
         - environment: staging
           s3_bucket: resume-staging
           cloudfront_id: ABC123
         - environment: prod
           s3_bucket: resume-prod
           cloudfront_id: XYZ789

Cache control headers for different file types:

   - name: Upload HTML files
     run: |
       aws s3 sync . s3://${{ env.S3_BUCKET }} \
         --exclude "*" \
         --include "*.html" \
         --cache-control "max-age=3600,public"

   - name: Upload assets
     run: |
       aws s3 sync ./assets s3://${{ env.S3_BUCKET }}/assets \
         --cache-control "max-age=31536000,public"

Preview deployments for pull requests:

   on:
     pull_request:
       branches: [ main ]
   jobs:
     deploy-preview:
       runs-on: ubuntu-latest
       steps:
         - name: Deploy to preview bucket
           run: aws s3 sync . s3://resume-preview-${{ github.event.number }}

Job apply strategies

zach beecher — Fri, 15 Aug 2025 15:52:46 +0000

Phased Approach: Breaking it into preparation, daily execution, application crafting, and long-term engagement makes it digestible and repeatable.

Specificity: You’re not just saying “optimize LinkedIn”, tools, and even suggested headlines. That’s gold.

Realistic Volume: 30–50 applications/week is ambitious but achievable with batching and automation.

AI with Integrity: You’re using AI to assist, not replace authenticity. That’s the right mindset.

Networking Strategy: You’re not afraid to reach out, and you understand the power of warm intros and referrals.

💡 Suggested Enhancements

Automate Job Tracking Instead of manually saving PDFs and updating spreadsheets, consider a script or tool that:

Scrapes job descriptions and saves them with structured filenames

Logs applications into a CSV or Notion database automatically

Flags duplicate applications or expired listings

I can help you build this in Bash or Python if you're interested.

Portfolio Integration Mention your GitHub, blog, or portfolio site in your resume and LinkedIn. Better yet:

Add a “Projects” section to LinkedIn with links

Use GitHub README files to explain project goals, tech stack, and outcomes

Create a simple static site (e.g., with AWS S3 + CloudFront) to showcase your resume and projects

Interview Prep Layer Add a Phase 5: Interview Readiness

Maintain a doc with common behavioral questions and STAR-format answers

Practice technical questions daily (e.g., LeetCode, Cloud Guru labs)

Record yourself answering questions to refine delivery

Weekly Review Ritual Every Sunday, review:

How many applications you submitted

Which ones got responses

What patterns you’re noticing (e.g., certain titles or companies responding more)

What you learned or built that week

This keeps you intentional and adaptive.

🧠 Final Thought
You’re not just applying for jobs—you’re building a system that compounds. Every tailored resume, every outreach message, every saved job description is a brick in the foundation of your next opportunity.

a Notion template, a Bash automation suite, or even a personalized job search dashboard. Just say the word.

notion template
Let’s build you a Notion template that mirrors your strategic job search plan—organized, actionable, and easy to maintain. This will help you track applications, prep for interviews, and stay focused on learning and networking.

🧱 Notion Template Structure
🗂️ Main Dashboard: Job Search HQ
A central page with links to all subpages and a weekly progress tracker.

📋 1. Job Applications Tracker (Database View)
Column Name Type Purpose
Company Text Name of the company
Job Title Text Specific role applied for
Date Applied Date When you submitted the application
Status Select Applied, Interviewing, Rejected, Offer
Job Description PDF File Upload saved job description
Resume Version Used Text Which tailored resume you used
Cover Letter Used Text Which cover letter version
Contacted Recruiter? Checkbox Did you reach out?
Notes Text Interview prep, follow-up, etc.
Views:

Kanban by Status

Calendar by Date Applied

Table view for sorting/filtering

🧠 2. Interview Prep Vault
Behavioral Questions (toggle list or database)

STAR-format answers

Common prompts like “Tell me about a time you failed”

Technical Questions

Categorized by topic (e.g., AWS, Bash, Python)

Include links to practice problems or your own notes

Company-Specific Prep

Subpages for each company with tailored prep notes

📚 3. Learning & Projects Log
Column Name Type Purpose
Topic Text e.g., Terraform, IAM Policies
Type Select Course, Blog, Project, Cert
Date Started Date When you began
Status Select In Progress, Completed
Notes Text What you learned, links, etc.
💬 4. Networking Tracker
Column Name Type Purpose
Name Text Person you contacted
Role Text Recruiter, Engineer, etc.
Company Text Where they work
Date Contacted Date When you reached out
Follow-Up Date Date When to follow up
Notes Text What you discussed, outcome
📈 5. Weekly Review Journal
Template with prompts:

How many jobs did I apply to?

What responses did I get?

What did I learn this week?

What will I improve next week?

Cloud eng/ dev Daily job search guide from a recruiter

zach beecher — Fri, 15 Aug 2025 15:37:35 +0000

Daily Job Search Strategy
Step Action Notes
1️⃣ Apply for 30 jobs/day Use batching: 10 in morning, 10 midday, 10 evening. Use saved searches to speed things up.
2️⃣ Use Google strategically Try "site:careers.company.com job title" or "intitle:job job title location" to find hidden gems.
3️⃣ Save job descriptions as PDFs Use Print → Save as PDF or browser extensions. Organize by folder: Applied/CompanyName/JobTitle.pdf.
4️⃣ Be specific with job titles Search for exact roles like “Cloud Support Engineer” or “DevOps Intern” rather than generic terms.
5️⃣ Use LinkedIn’s “<10 applicants” filter Prioritize these for higher visibility. Combine with “Easy Apply” for speed.
6️⃣ Internships & volunteering Look for open-source projects, nonprofit tech roles, or startup gigs. Experience is experience.
7️⃣ Network intentionally Message alumni, attend virtual meetups, comment on posts. Ask for advice, not jobs.
8️⃣ Tailor your resume Use keywords from the job description. Highlight relevant projects and skills.
9️⃣ Write a compelling cover letter Focus on how you solve problems, not just what you’ve done. Keep it concise and specific.
🔟 Optimize LinkedIn Use a strong headline, detailed experience, and a custom URL. Ask for endorsements.
1️⃣1️⃣ Commit to learning Take short courses, build projects, or write blog posts. Show growth and curiosity.

Setup google alerts with scripts running on topics like new job postings on your favorite companies. Be organized, keep a spreadsheet and do followups 1-2 weeks after apply. Find a recruiter at said company and message them.

Use a spreadsheet or Notion board with columns like:

Company

Job Title

Date Applied

Status (Applied, Interviewing, Rejected)

PDF Link

Notes (e.g., who you networked with)

Bash script to generate 25 files, a resource, a guide, challenge yourself

zach beecher — Fri, 15 Aug 2025 15:33:11 +0000

**The Challenge
**Write a Bash script based on the following requirements:

Creates 25 empty (0 KB) files. (Hint: Use the touch command.)

The file names should be , , , and so on.

Design the script so that each time you run it, it creates the next batch of 25 files with increasing numbers starting with the last or maximum number that already exists.
Do not hard code these numbers. You need to generate them by using automation.

Test the script. Display a long list of the directory and its contents to validate that the script created the expected files.

At first glance I'm thinking I need a way to check the system for current number of files, so I start searching:

I'll need a dynamic loop, checking system files for numbers so I search for lookup methods, grep comes up and find comes up as well:

[Link(https://stackoverflow.com/questions/24655436/how-can-i-find-a-file-directory-that-could-be-anywhere-on-linux-command-line)] To get rid of permission errors (and such), you can redirect stderr to nowhere

find / -name "something" 2>/dev/null

I've heard of this null thing before, and it's pretty neat. I found an interesting reason to use this, the 2> is a bash syntax to tell the system to redirect stderr (2) so all errors will be ignored, and the carrot > redirects stdout. I was doing some bandit over the wire hacking, and often times to get around the permissions errors, you chmod 400 the file if you have permission if not copy file and make a tmp directory and paste into that directory and work on it there.

Here's the final code (we can walk through it as a team):

`#!/bin/bash

yourName="zach"
logFile="file_creation.log"

Get list of existing files matching the pattern

existingFiles=$(ls ${yourName}[0-9]* 2>/dev/null)

Extract the highest number from existing files

if [ -z "$existingFiles" ]; then
maxNum=0
else
maxNum=$(echo "$existingFiles" | grep -oP "${yourName}\K[0-9]+" | sort -n | tail -1)
fi

Timestamp for this batch

timestamp=$(date '+%Y-%m-%d %H:%M:%S')
echo "[$timestamp] Creating files starting from ${yourName}$((maxNum + 1)) to ${yourName}$((maxNum + 25))" >> "$logFile"

Create 25 new files and log each one

for ((i=1; i<=25; i++)); do
newNum=$((maxNum + i))
fileName="${yourName}${newNum}"
touch "$fileName"
echo "[$timestamp] Created $fileName" >> "$logFile"
done

Show the results

echo "Created files:"
ls -l ${yourName}[0-9]* | tail -25

!/bin/bash -> tells system to use Bash to interpret the code

yourName="zach"
logFile="file_creation.log"

--> setting up basic static variables:

existingFiles=$(ls ${yourName}[0-9]* 2>/dev/null)
--> 2>/dev/null suppresses errors if no files exist yet. Lists all files match pattern.

if [ -z "$existingFiles" ]; then
maxNum=0
else
maxNum=$(echo "$existingFiles" | grep -oP "${yourName}\K[0-9]+" | sort -n | tail -1)
fi

--> checks if any matching files exist, if none exist start numbering from 0, If files do exist:

grep -oP "${yourName}\K[0-9]+" extracts just the number part from filenames.

sort -n sorts numerically.

tail -1 grabs the highest number so we can start from there.

timestamp=$(date '+%Y-%m-%d %H:%M:%S')
--> captures date saves for logging

echo "[$timestamp] Creating files starting from ${yourName}$((maxNum + 1)) to ${yourName}$((maxNum + 25))" >> "$logFile"
--> logs batch file_creation.log

for ((i=1; i<=25; i++)); do
newNum=$((maxNum + i))
fileName="${yourName}${newNum}"
touch "$fileName"
echo "[$timestamp] Created $fileName" >> "$logFile"
done
--> meat of the operation here, 25 loops calculates next num +1 - creates files with touch, logs them with time stamp

echo "Created files:"
ls -l ${yourName}[0-9]* | tail -25
--> displays last 25 files (can use head as well to see the first 25 but doesn't add much value.

Now that's all of the code. It's a lot to take in as a beginner bash scripter. One thing to take note of is the programmatic approach to solve this, you can't hard code the for loop and just have it work. It needs to do a few things so good to research grep, find, sort, tail functions in bash.

Wish you all the best,

AWS VPC and EC2 basic setup (manual)

zach beecher — Tue, 12 Aug 2025 20:34:36 +0000

Learning cloud I wanted a place I can quickly find a step by step guide to launch VPC and EC2:

Quick AWS Management Console steps (visual, good for first-time use)

1 — Overview
A custom VPC (10.0.0.0/16).
A public subnet (10.0.1.0/24) with auto-assign public IPs.
An Internet Gateway (IGW) and a route for 0.0.0.0/0 → IGW.
A security group allowing SSH (22) from your IP and HTTP (80) from anywhere (optional).
A key pair to SSH.
One EC2 instance (Amazon Linux 2 example) in the public subnet.
2 — Console steps (fastest visually)
Sign in to the AWS Console and pick a region (top-right).
Go to VPC service → Your VPCs → Create VPC:
Name: my-vpc
IPv4 CIDR block: 10.0.0.0/16
Create.
Enable DNS hostnames (if not auto-enabled): select VPC → Actions → Edit DNS hostnames → Enable.
Create subnet: Subnets → Create subnet:
VPC: my-vpc
Name: public-subnet-1
IPv4 CIDR: 10.0.1.0/24
AZ: pick one (e.g., us-east-1a)
Create.
Then, with subnet selected: Actions → Modify auto-assign IP settings → enable Auto-assign public IPv4 address.
Internet Gateway: Internet Gateways → Create internet gateway → name my-igw → Create, then Attach to my-vpc.
Route table: Route Tables → create a route table for my-vpc (name public-rt). Edit routes: add route 0.0.0.0/0 → target: my-igw. Then Subnet Associations → Associate public-subnet-1.
Security group: EC2 → Network & Security → Security Groups → Create security group:
Name: my-sg, VPC: my-vpc
Inbound rules: SSH (TCP 22) — Source: Your IP (use “My IP” option); HTTP (TCP 80) — Source: 0.0.0.0/0 (if you want web).
Create.
Key pair: EC2 → Key Pairs → Create key pair → give name my-key → download .pem and store securely; chmod 400 my-key.pem.
Launch EC2:
EC2 → Instances → Launch instances.
Choose an AMI (e.g., Amazon Linux 2 or Ubuntu — note username differs).
Instance type: t3.micro or t2.micro (free-tier eligible if your account qualifies).
Under Network settings: VPC: my-vpc, Subnet: public-subnet-1, Auto-assign Public IP: enabled.
Select Security group: my-sg.
Key pair: my-key.
Launch.
After instance status is running, grab the Public IP and SSH:
Amazon Linux 2 → ssh -i my-key.pem ec2-user@PUBLIC_IP
Ubuntu → ssh -i my-key.pem ubuntu@PUBLIC_IP

Under the user settings on Ec2 add this bash script to pull in a website template if you want to show your friends.

#!/bin/bash sudo yum update -y sudo yum upgrade -y sudo yum install httpd -y sudo yum install unzip -y sudo wget --no-check-certificate 'https://drive.google.com/uc?export=download&id=1wO2DwQ5KgiBeP9dg51H6hw95et89WlUo' -O tempsite.zip sudo unzip tempsite.zip -d /var/www/html sudo mv /var/www/html/tempsite/* /var/www/html/ sudo systemctl enable httpd sudo systemctl start httpd

courtesy of: https://syang.substack.com/p/think-of-aws-vpc-like-a-parking-lot

OFC There's a faster way to launch VPC and Ec2 but this is breaking down each step and it's important to know what subnets are doing (10.0.0.0/16 (~65k IPs, -5 for amazon), internet gateway, Routes, Ec2 runs on VPC so if you know Ec2 is having issues, check the routes, subnets, do they have access to Internet gateway (auto resolved hosts or assigned Public IP) - go through the check list in order.

Fascinating stuff. Can't wait to learn more

Bash commands for AWS Cloud engineers

zach beecher — Tue, 12 Aug 2025 19:48:08 +0000

Learning AWS cloud I stumbled onto Bash commands which got me thinking - which ones are key to a cloud engineer's toolbox?

*Wanna quickly edit EC2 instances and metadata?
*
`#!/bin/bash
echo "Fetching EC2 instances and their tags..."

aws ec2 describe-instances \
--query 'Reservations[].Instances[].[InstanceId,Tags]' \
--output table`

are wildcards so it'll pull down all reserved instances

*Wanna see S3 bucket backups?
*
`#!/bin/bash
SOURCE_BUCKET="my-source-bucket"
DEST_BUCKET="my-backup-bucket"
DATE=$(date +%Y-%m-%d)

echo "Backing up $SOURCE_BUCKET to $DEST_BUCKET/$DATE..."

aws s3 sync s3://$SOURCE_BUCKET s3://$DEST_BUCKET/$DATE --storage-class STANDARD_IA
`

Daily backup and version / archive storage

*Wanna rotate IAM access keys?
*
`#!/bin/bash
USER_NAME="your-iam-user"

echo "Creating new access key..."
NEW_KEY=$(aws iam create-access-key --user-name $USER_NAME)

echo "Disabling old access keys..."
OLD_KEYS=$(aws iam list-access-keys --user-name $USER_NAME --query 'AccessKeyMetadata[*].AccessKeyId' --output text)

for KEY in $OLD_KEYS; do
aws iam update-access-key --user-name $USER_NAME --access-key-id $KEY --status Inactive
done
`

Rotate keys daily to ensure security is hygenic

*Wanna check the CPU utillization of EC2?
*

`#!/bin/bash
INSTANCE_ID="i-xxxxxxxxxxxxxxxxx"
REGION="us-west-2"

aws cloudwatch get-metric-statistics \
--namespace AWS/EC2 \
--metric-name CPUUtilization \
--dimensions Name=InstanceId,Value=$INSTANCE_ID \
--start-time $(date -u -d '10 minutes ago' +%Y-%m-%dT%H:%M:%SZ) \
--end-time $(date -u +%Y-%m-%dT%H:%M:%SZ) \
--period 300 \
--statistics Average \
--region $REGION \
--output table
`
Wanna kill unused EC2s by tag (save dat money)

`#!/bin/bash
TAG_KEY="Environment"
TAG_VALUE="Dev"

echo "Finding EC2 instances with tag $TAG_KEY=$TAG_VALUE..."

INSTANCE_IDS=$(aws ec2 describe-instances \
--filters "Name=tag:$TAG_KEY,Values=$TAG_VALUE" "Name=instance-state-name,Values=running" \
--query "Reservations[].Instances[].InstanceId" \
--output text)

echo "Terminating instances: $INSTANCE_IDS"
aws ec2 terminate-instances --instance-ids $INSTANCE_IDS
`

Cleans up dev env automagically

Let me know which Bash scripts you reccomend, or use as your daily drivers?