AccessTracker — Full Stack Accessibility Bug Reporting Platform

The Problem

Accessibility issues are often mixed together with general application reviews. When there are many other bugs and reviews, an accessibility problem can be missed or ignored.

People need a focused place where they can discover accessibility issues before depending on an application. Developers also need structured reports that explain the application version, platform, screen reader, severity, reproduction steps, and device context.

The Idea

I built AccessTracker as a community-driven accessibility knowledge base. The platform is focused only on accessibility issues, so users can search, compare, and understand accessibility problems without filtering through unrelated application bugs.

Anyone with an account can report an accessibility bug. Other people can then read the report and share whether they experience the same problem in their own environment.

Version-Aware Bug Reports

The application version is required when creating a bug report. This is important because an accessibility problem may exist in one version and be fixed or changed in a later version.

For example, someone may report a problem in version 3.2. A person testing version 3.3 may verify that the problem is fixed for them. Keeping the version with the report and verification makes those different experiences easier to understand.

Reports also include information such as the application, platform, screen reader, severity, reproduction steps, and device context. This gives the report more useful detail than a general statement that an application is or is not accessible.

Community Verification

A community member can verify a bug based on their own environment. The verification can communicate different experiences, such as:

  • I am having this problem.
  • I do not have this problem.
  • This problem is fixed for me.

Verification is tied to the application version and the person's environment. This means the platform does not treat one person's experience as the final answer for everyone.

The platform shows verification summaries and statistics for a bug. For example, the summary might show that 10 people say it is fixed for them, 2 people still experience it, and 15 people do not experience it. Users and developers can compare those results with the reported application versions and environments.

These statistics help the accessibility community understand how widespread or version-specific a problem may be. They can also help developers see whether a change improved the experience for some users while leaving a problem for others.

Developer Responses

AccessTracker also supports responses from developers connected to an application. A person can claim developer status by providing evidence of their relationship with the application.

Once that relationship is approved, the developer can publish an official response to a bug. The response is displayed prominently so that users can see the developer's explanation alongside the community experiences.

The backend checks both the developer role and the approved application relationship before allowing a response to be created. Response ownership is also enforced when a response is edited or deleted.

In the current MVP, developer application and approval workflows are not yet implemented as user-facing features. Approved relationships are manually inserted into MongoDB for the demonstration.

Building the Backend

I organized the FastAPI backend around features such as authentication, applications, bugs, developers, and verifications. Each feature follows the same request flow:

FastAPI routes → services → repositories → MongoDB

Routes handle HTTP requests, services contain application rules, and repositories handle database operations. This keeps the logic for reports, verifications, and developer responses separate from the request handlers.

Authentication and Security

Registration uses email OTP verification. Passwords are hashed with Argon2 and are never stored as plain text. OTPs are temporary Redis records and are protected with application-level hashing.

After login, the application uses short-lived JWT access tokens and rotating refresh tokens. Refresh-token sessions are stored in MongoDB as hashes, not as plain-text tokens. The application also supports password reset, logout, and session revocation.

The backend enforces ownership for bug reports and community verifications. It also checks administrator permissions for protected operations and applies the developer and application relationship checks before allowing official responses.

Frontend and Backend Connection

The client is built with Flutter Web and communicates with the FastAPI backend through REST APIs. I organized the client using the same feature boundaries as the backend.

Riverpod handles state management and dependency injection. Dio handles HTTP communication and authentication interceptors, while GoRouter handles navigation and authentication guards.

The frontend uses Flutter Secure Storage for client-side token storage and Flutter Dotenv for environment-based configuration.

Current MVP Boundaries

The current version focuses on the core reporting and verification workflow. Developer approval is manual, there is no admin dashboard, and developer responses are not formal decisions that a bug is fixed.

Comments, notifications, analytics, moderation, pagination, and native mobile and desktop clients are deferred. The current client targets Flutter Web.

What I Practiced

This project gave me practice with API design, validation, authentication, token lifecycle management, password security, MongoDB data modeling, Redis workflows, email integration, role-based access, ownership enforcement, and feature-based backend architecture.

Technology Stack

Python, FastAPI, Pydantic, PyMongo, MongoDB, Redis, Argon2, PyJWT, Resend, Flutter Web, Riverpod, Dio, GoRouter, Flutter Secure Storage, and Flutter Dotenv.

View GitHub Repository