AWS Builder Center
Weekend Showcase Challenge: AuraAudit

Weekend Showcase Challenge: AuraAudit

AuraAudit is a real-time web accessibility (WCAG 2.2) and serverless performance diagnostic tool powered by AWS Lambda, Amazon Bedrock (Nova Micro), and AWS Amplify. Features batch URL scanning, mobile viewport simulation, and automated code patch remediation.

Engineering software solutions for big real-world impact.

Vision & What It Does

Modern web development moves fast, but accessibility compliance and performance hygiene are frequently treated as post-launch triage rather than core engineering fundamentals. Developers typically face a frustrating trade-off: either install heavy, browser-dependent CLI suites that slow down continuous integration pipelines, or manually cross-reference dense documentation to diagnose compliance failures.
AuraAudit is a real-time, serverless diagnostic web application engineered for the AWS Builder Center Showcase Challenge. It provides developers and site owners with an instant, zero-infrastructure accessibility and performance auditing engine.
Instead of provisioning heavy headless browser clusters or relying on bloated testing suites, AuraAudit inspects server-rendered web documents using an ultra-lightweight DOM extraction pipeline. It packages structural document telemetry and streams it to Amazon Bedrock (Nova Micro) to perform semantic evaluation against WCAG 2.2 (Level A & AA) standards.
Core Capabilities
  • WCAG 2.2 Compliance Scoring: Audits non-text content, heading hierarchy parity ( <h1> – <h6> ), input-to-label bindings, unlabelled interactive buttons, and document language declarations.
  • Viewport Simulation: Allows developers to toggle between Desktop Mode and Mobile Viewport Mode, evaluating viewport scaling constraints (such as  user-scalable=no  and maximum scale limits) that violate WCAG Criterion 1.4.4 (Resize Text).
  • Multi-URL Concurrent Diagnostics: Accepts comma-separated or newline-separated URL manifests, executing parallel serverless inspections via multithreading without degrading latency.
  • Automated Code Remediation: Delivers concrete, copy-paste HTML, CSS, and JS code patches for every identified issue, eliminating the guesswork in fixing accessibility violations.
  • Performance & Security Hygiene: Tracks Time to First Byte (TTFB), payload weight, Content Security Policy (CSP) presence, and HSTS headers.



How I Built It

The primary architectural goal was to build a sub-second, production-grade diagnostic pipeline operating entirely within AWS Free Tier primitives.

Key Engineering Decisions & Implementation Details

  1. Foundation Model Selection (Bedrock Nova Micro): I selected amazon.nova-micro-v1:0 for its high inference velocity, cost efficiency, and strong adherence to strict JSON schemas. Because the application produces actionable developer remediation diffs, deterministic JSON formatting without conversational markdown artifacts was essential.
  1. Deterministic DOM Inspection: To keep execution times under 500ms per target site, I built a custom parser using Python's built-in html.parser.HTMLParser. This inspects raw DOM elements (image alt parity, <label> associations, interactive button text names, and metadata) directly in memory with zero external package dependencies.
  1. Cross-Region Serverless Architecture: The compute engine runs in AWS Lambda in Sydney (ap-southeast-2), while Bedrock runtime invocations route directly to us-east-1 over the AWS global backbone via boto3. This demonstrates seamless cross-region integration without requiring local model hosting.
  1. Concurrent Batch Auditing: Leveraging Python's concurrent.futures.ThreadPoolExecutor, the backend processes up to 3 target URLs simultaneously. Each URL is fetched, analyzed, and audited concurrently, keeping total response times under 3 seconds for batch runs.
  1. Modern Glassmorphic Frontend: The user interface is built with vanilla HTML5, CSS Grid, and JavaScript, hosted globally via AWS Amplify. It features responsive status gauges, tabbed multi-site switching, and one-click code copy blocks.

Challenges Encountered & Overcome

  • CORS Pre-Flight & Gateway Header Deduplication: Initial browser invocations resulted in Failed to fetch errors due to CORS mismatches between the Lambda Function URL built-in CORS configuration and manual response headers. I resolved this by standardizing the Lambda Function URL CORS settings and returning pure JSON payloads.
  • Base64 Payload Normalization: Certain browser network layers send JSON payloads encoded in Base64 when dispatching POST requests to Function URLs. I implemented a defensive decoding middleware in the Lambda handler to ensure seamless payload parsing across all client environments.
  • Mobile-First Accessibility Edge Cases: Distinguishing desktop markup from mobile-specific accessibility blockers required auditing <meta name="viewport"> attributes. I configured the parser to flag restrictive scaling directives that prevent users with low vision from zooming.



AWS Services Used / Architecture Overview

┌──────────────────────────────────────────────┐
│ AWS Amplify Hosting │
│ (Interactive Diagnostic UI) │
└──────────────────────┬───────────────────────┘
│
│ 1. HTTPS POST (Target URLs & Viewport Mode)
▼
┌──────────────────────────────────────────────┐
│ AWS Lambda (Python 3.12) │
│ (AuraAudit-Engine + Function URL) │
└──────────────────────┬───────────────────────┘
│
│ 2. Extracted Structural Telemetry
▼
┌──────────────────────────────────────────────┐
│ Amazon Bedrock │
│ (Nova Micro Engine) │
└──────────────────────┬───────────────────────┘
│
│ 3. WCAG 2.2 Scores & Code Patches
▼
┌──────────────────────────────────────────────┐
│ Amplify Dashboard UI │
│ (Instant Audit Report Display) │
└──────────────────────────────────────────────┘

  • AWS Amplify Hosting: Delivers continuous Git-based deployment, global edge CDN caching, and SSL termination for the frontend dashboard.
  • AWS Lambda (Python 3.12): Executes the backend audit pipeline, orchestrating DOM inspection, network telemetry collection, and parallel Bedrock queries.
  • Amazon Bedrock (amazon.nova-micro-v1:0): Provides the foundation model intelligence to evaluate telemetry against WCAG 2.2 criteria and generate clean code remediation blocks.
  • Lambda Function URLs: Provides a secure, low-latency HTTPS endpoint with configurable CORS controls, bypassing the need for dedicated API Gateway instances.



Verification & Proof of Working Functionality

Multi-URL & Viewport Diagnostic Dashboard
Dashboard

Output

AWS Lambda Function & Function URL Configuration
AWS Lambda

AWS Lambda Test

AWS Lambda Function & Function URL Configuration
AWS Amplify Interface




What I Learned Across the Summer

Building across the AWS Summer Challenges has been a transformative engineering journey that redefined how I approach cloud architecture, AI integration, and developer tooling:
  1. The Power of Hybrid Architecture (Deterministic Compute + Generative AI):
  • The most responsive and cost-effective applications don't ask Large Language Models to do everything. Offloading raw telemetry collection, structured parsing, and network measurements to lightweight deterministic code (like serverless Python routines) while reserving foundation models for semantic synthesis, contextual reasoning, and code remediation yields sub-second user experiences at virtually zero operating cost.
  1. Event-Driven and Decoupled Intelligence:
  • Exploring decoupled cloud architectures taught me how to shift computationally heavy or recurrent tasks to asynchronous background pipelines. Orchestrating serverless execution with automated event triggers and managed storage patterns demonstrated that the most impactful developer tools often work autonomously behind the scenes.
  1. Model Right-Sizing for Specialized Workloads:
  • Bigger isn’t always better. Lightweight, fast-inference foundation models like Amazon Bedrock Nova Micro excel at structured evaluation, automated code diff generation, and domain-specific validation. When guided by strict schema contracts, smaller models deliver high precision, lower latency, and minimal token consumption.
  1. Cross-Region Resilience and Serverless Edge Delivery:
  • Navigating multi-region routing, fine-tuning CORS headers across serverless function gateways, handling base64 payload normalization, and deploying global edge frontends via continuous Git-driven pipelines cemented best practices for building robust, production-grade cloud applications.



Link to App or Repo




Tag a Builder Who Inspired Me

A massive thank you to the entire AWS Builder Center Community - seeing everyone's creative submissions week after week has been a tremendous source of motivation and learning!
A special shout-out to Lewis Sawe for the incredible work on "The Museum That Grows" during the creative challenge, which brilliantly demonstrated the potential of persistent digital experiences and autonomous agents. Thanks as well to Ben Fowler and the AWS community team for orchestrating an unforgettable Summer Build Series!
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