AWS Builder Center
Full Stack Challenge: ChronoGhost

Full Stack Challenge: ChronoGhost

Modern websites are bogged down by megabytes of scripts, trackers, and runtime bloat. ChronoGhost is a 100% serverless full-stack app that excavates the underlying semantic HTML artifact, calculates payload reduction with 56k dial-up telemetry, and logs audit snapshots to DynamoDB.

Engineering software solutions for big real-world impact.

Vision and What It Does

Modern web experiences have evolved into complex software ecosystems. However, this evolution has introduced massive digital bloat: multi-megabyte JavaScript bundles, nested styling frameworks, advertising tracking pixels, and analytics beacons. For users on constrained bandwidth or legacy devices, simply trying to read core textual information has become needlessly sluggish and resource-heavy.
I conceived ChronoGhost around the hackathon prompt word ARTIFACT. I decided to approach the modern web through the lens of digital archeology: treating bloated web pages as layered digital ruins where the core semantic HTML represents the preserved artifact. With ChronoGhost, users can enter any public website URL to strip away trackers, scripts, and runtime overhead via serverless compute. My application isolates and exposes the pure semantic structure of the document, re-rendering it through nostalgic design paradigms (Windows 95 Classic Light Mode and 1980s Phosphor CRT Dark Mode), paired with historical 56k dial-up load metrics and persistent audit telemetry.



Full Stack Breakdown (The Code.TV Journey)

I engineered ChronoGhost by following the five core product development phases taught across the Code.TV series:
  1. Pitch: I identified a common friction point - modern web bloat obscures raw textual content. I pitched ChronoGhost as a distraction-free, serverless reader and web performance auditor wrapped in a tactile retro aesthetic.
  1. Prototype: I rapidly validated the core sanitization engine using a headless Node.js script. I used native regular expressions and buffer byte-length calculations to prove that I could achieve 80%+ payload reduction without breaking content hierarchy.
  1. MVP: I connected my compute layer to a public AWS Lambda Function URL, integrated Amazon DynamoDB for snapshot auditing, and developed a responsive single-page application to trigger scans and display sanitized DOM trees in real time.
  1. UX: I focused heavily on tactile nostalgia and interaction polish. I built Web Audio API dial-up modem synthesis for acoustic feedback on scan, applied CRT scanline rasterization filters, and engineered a seamless dual-theme toggle.
  1. Launch: I deployed the entire static application globally using AWS Amplify Hosting to achieve instant edge distribution with zero fixed operational overhead.



How I Built It

I designed ChronoGhost as a zero-dependency full-stack application that runs 100% within the AWS Free Tier.
The backend consists of an AWS Lambda function running Node.js 20.x/24.x. When a user requests an excavation, my Lambda handler performs a server-side fetch with custom headers, measures round-trip execution latency, calculates byte sizes, and strips out non-semantic overhead ( <script> ,  <style> ,  <iframe> ,  <svg> ,  <form> ,  <nav> ). It computes the payload reduction ratio and historical 56k baud transfer times, then asynchronously persists the audit snapshot to an Amazon DynamoDB table ( ChronoGhostArtifacts ).
One key challenge I encountered during development was Cross-Origin Resource Sharing (CORS). Initially, duplicate CORS headers were returned by both my Lambda application code and the Lambda Function URL infrastructure, leading to browser preflight rejections. I resolved this cleanly by delegating CORS handling directly to the AWS Lambda Function URL configuration layer and keeping the application code focused strictly on payload processing and database operations.
For the frontend, I used pure semantic HTML5, modern Tailwind CSS, and vanilla JavaScript. This kept client-side asset sizes minimal and ensured near-instant First Contentful Paint (FCP).



AWS Services / Architecture

  • Compute: AWS Lambda (Node.js 20.x/24.x) handles server-side document fetching, DOM sanitization, payload calculations, and historical transfer heuristics.
  • Database: Amazon DynamoDB stores a persistent archeological audit history and snapshot telemetry metadata for every excavated URL.
  • API & Ingress: AWS Lambda Function URL provides an auto-scaling, low-latency public HTTPS endpoint with native CORS configuration.
  • Hosting & CDN: AWS Amplify Hosting distributes the static single-page application across Amazon's global edge network with automated SSL and edge caching.
Architecture




What I Learned

Building ChronoGhost reinforced for me the speed and efficiency of serverless event-driven architectures for document and text processing. Using AWS Lambda Function URLs allowed me to create a direct, low-latency API without the added setup overhead of a dedicated API Gateway for a lightweight microservice. Additionally, integrating DynamoDB seamlessly into the execution flow demonstrated how easily managed NoSQL databases can provide historical state without server management overhead.



Link to App or Repo

Visual Proofs:
Dark Mode Dashboard

Light Mode Dashboard

Working Application

DynamoDB Table

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article