AWS Builder Center
Weekend Annoying Task Challenge: BugSnap

Weekend Annoying Task Challenge: BugSnap

BugSnap is a browser-based tool that helps testers create clear and reproducible UI bug reports by combining screenshot annotation and structured bug-report writing in one place.

The Annoying Task

Turning a UI observation into a complete defect report is a small task that repeats throughout every sprint and work week.
A tester captures a screenshot, opens an image-editing tool to mark the problem, switches to a document or issue tracker, writes the reproduction steps, adds environment details, selects a severity, and attaches everything to the defect.
This process is repetitive and can result in incomplete reports.
A screenshot may show what went wrong, but it may not explain:
  • What the tester was trying to do
  • How to reproduce the issue
  • What was expected
  • What actually happened
  • Which build or environment was affected
  • How serious the issue is
When this information is missing, developers may need to ask follow-up questions before they can investigate the problem.
BugSnap solves this focused annoyance: creating a clear UI bug report quickly.

Vision and What the App Does

BugSnap provides a single workspace for preparing visual and textual defect information.
A tester can upload a PNG or JPG screenshot and mark the problem directly on the image using:
  • Rectangle
  • Arrow
  • Circle
  • Freehand drawing
  • Text label
  • Undo
  • Clear
The tester can then complete the report using these fields:
  • Bug title
  • Steps to reproduce
  • Expected result
  • Actual result
  • Environment and build information
  • Severity
Severity options include Critical, High, Medium, and Low. Critical and High issues are displayed with a red badge so important defects are immediately visible.
BugSnap also includes a Sample Bug button. It loads example information for a common login issue where the login button remains disabled even after valid credentials are entered.
The application is designed for QA testers, developers, product managers, designers, and support teams who need to explain UI defects quickly and clearly.

The Main Feature: Screenshot and Explanation in One Workflow

The main feature of BugSnap is its live report preview.
As the tester adds annotations and completes the report fields, BugSnap shows how the final defect report will look.
The completed report can be:
  • Copied to the clipboard
  • Exported as an annotated PNG screenshot
  • Exported as a Markdown bug report
The Markdown report contains:
  • Bug title
  • Severity
  • Environment and build information
  • Steps to reproduce
  • Expected result
  • Actual result
  • A reference to the screenshot evidence
This makes the report easy to paste into a defect tracker, pull request, team message, documentation page, or support ticket.
The goal is to make the defect understandable without requiring multiple clarification messages between testers and developers.

How You Built It

BugSnap was built using:
  • React
  • TypeScript
  • Vite
  • HTML Canvas
  • Modern CSS
  • Browser localStorage
  • Browser Clipboard APIs
  • Client-side file download APIs
The screenshot is processed entirely inside the browser.
When an image is selected, BugSnap loads it into the browser and displays it on a canvas. The annotation tools draw directly over the image. Large images are safely resized in the browser to reduce memory usage and improve usability.
The application stores only the text fields in browser localStorage. This allows the report content to be restored after refreshing the page.
The screenshot is not stored in localStorage. If the page is refreshed, the tester must upload the screenshot again.
The export process is also handled locally:
  1. The annotated canvas is converted into a PNG file.
  1. The report data is converted into Markdown.
  1. Both files are downloaded directly to the user’s device.
No backend API is required for the core workflow.

Implementation Challenges and Decisions

The first challenge was handling large screenshots without a backend. Large images can consume significant browser memory, so BugSnap resizes them inside the browser before processing.
The second challenge was supporting several annotation types while keeping the image and drawings together. HTML Canvas provides one drawing surface for the uploaded image and all visual annotations.
The third challenge was preserving report information after a page refresh without permanently storing the screenshot. I solved this by storing only the text fields in localStorage while requiring the screenshot to be uploaded again after a reload.
Another important decision was to keep the screenshot processing completely local. This avoids unnecessary data transfer and means screenshots are not uploaded to a server, stored in a database, or sent to an AI service.

AWS Services Used and Architecture Overview

 AWS Amplify Hosting  is the only AWS service used by BugSnap.
Amplify Hosting hosts the static React application and builds it using the project’s  amplify.yml  configuration.
BugSnap does not use:
  • A backend server
  • A database
  • User authentication
  • Amazon S3 for screenshot storage
  • AWS Lambda
  • Amazon Bedrock
  • Paid external APIs
The architecture is intentionally simple.
AWS Amplify Hosting
|
| Builds and serves the static React application
v
User Browser
|
|-- HTML Canvas: screenshot annotation
|
|-- Browser memory: image processing
|
|-- localStorage: report text restoration
|
|-- Clipboard API: copy report
|
|-- Local downloads: PNG and Markdown exports
BugSnap does not use an AI agent or backend workflow, so no agent is triggered. The user triggers the application workflow by uploading a screenshot and selecting annotation, preview, copy, or export actions. All processing happens locally in the browser.
The screenshot never leaves the browser during the normal workflow.

Privacy and Data Handling

BugSnap was designed with a browser-only privacy model.
The uploaded screenshot:
  • Is never uploaded to a server
  • Is not stored in a database
  • Is not sent to an AI service
  • Is processed only inside the browser
  • Is downloaded locally only when the tester exports it
The report text is stored only in the browser’s localStorage so it can be restored after a refresh.
Because BugSnap does not have a backend, reports are not synchronized across devices and there is no centralized copy of the screenshot or report.
This design keeps the application lightweight and avoids requiring user accounts or server-side storage for a simple reporting task.

Demonstration Flow

A typical BugSnap demonstration follows this sequence:
  1. Open BugSnap in a browser.
  1. Click Sample Bug to load example login defect information.
  1. Upload a PNG or JPG screenshot.
  1. Draw a rectangle around the affected login button.
  1. Add an arrow or text label to highlight the problem.
  1. Enter the bug title and reproduction steps.
  1. Add the expected and actual results.
  1. Enter environment and build information.
  1. Select a severity such as High.
  1. Review the live report preview.
  1. Copy the report to the clipboard or export the PNG and Markdown files.
  1. Paste the Markdown report into an existing defect-tracking workflow.
This demonstrates the complete journey from a raw screenshot to a structured bug report.

Why BugSnap Is Different

BugSnap is not intended to replace a full defect-management system.
Its purpose is to solve the small but frequent preparation step that happens before a defect is submitted.
BugSnap combines:
  • Visual evidence
  • Direct screenshot annotation
  • Structured reproduction information
  • Severity classification
  • Live preview
  • Clipboard copy
  • Markdown export
  • Local browser processing
The tester does not need to switch between an image editor, a notes application, and a report template.
BugSnap also works without authentication, a database, or a backend service. This makes it quick to open and useful for testers, developers, product managers, designers, and support teams.
The main idea is simple:
Make UI defects easier to understand before they reach the development team.

What I Learned

Building BugSnap provided several useful lessons.
I learned that a screenshot alone is often not enough to explain a software defect. Visual evidence becomes much more useful when it is connected to reproduction steps, expected behavior, actual behavior, and environment information.
I also learned that browser capabilities can support practical productivity tools without requiring a backend.
Important lessons from the project include:
  • HTML Canvas can support practical image annotation features.
  • Large images should be resized carefully to reduce browser memory usage.
  • Form data and image data should be handled separately.
  • localStorage is useful for restoring text fields but is not suitable for storing large screenshots.
  • Browser APIs can support clipboard copy and local file downloads.
  • A live preview helps users identify missing report information before exporting.
  • Privacy can be part of the product design even in a small application.
  • AWS Amplify Hosting is sufficient for deploying a static React application.
  • A focused tool does not need a complex architecture to solve a real workplace problem.

Future Improvements

Possible future enhancements include:
  • Drag-and-drop screenshot upload
  • Pasting screenshots directly from the clipboard
  • Multiple screenshots in one report
  • Editing or moving existing annotations
  • Screenshot blur and sensitive-data redaction
  • Bug-report templates for Jira, GitHub, and other tools
  • PDF export
  • Custom severity levels and labels
  • Dark mode
  • IndexedDB support for temporary image persistence
  • Optional team workspaces with secure server-side storage
  • Integration with defect-management systems
These improvements could extend BugSnap from a standalone reporting helper into a broader lightweight quality-assurance collaboration tool.

Final Summary

BugSnap is a simple browser-based application that turns an annotated screenshot and structured information into a clear UI bug report.
It reduces the effort required to explain a defect by combining screenshot marking, report writing, live preview, clipboard copy, and Markdown export in one workflow.
The application is intentionally lightweight:
  • React and TypeScript frontend
  • HTML Canvas annotation
  • Browser-only screenshot processing
  • localStorage for report text restoration
  • AWS Amplify Hosting for deployment
  • No backend, database, authentication, or paid external API
BugSnap addresses a small but common workplace annoyance: spending too much time preparing bug reports and still leaving important details unclear.



Link to App or Repository




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