FixForward AI

An AI-powered appliance repair coordinator that connects troubleshooting, warranty checks, repair tracking, and appointment recovery in one intelligent workflow.

Comment

Inspiration

When a household appliance breaks down, identifying the problem is only the beginning. Users may need to troubleshoot the issue, check warranty information, arrange a repair, book an appointment, and deal with rescheduling if a technician cancels.

These activities are often disconnected, forcing users to coordinate the entire process themselves.

We asked ourselves: What if an AI assistant could do more than answer questions and help coordinate the entire repair journey?

That idea inspired FixForward AI: an AI-powered appliance repair coordinator designed to bring troubleshooting, warranty checks, repair case management, and appointment recovery into one connected workflow.

Our vision is to make appliance repair simpler, more transparent, and easier to manage through conversational AI and structured automation.

What it does

FixForward AI helps users navigate the appliance repair process through a conversational assistant and an interactive repair dashboard.

Key features include:

AI-powered troubleshooting: Users describe their appliance problems in natural language and receive relevant troubleshooting guidance.

Warranty checks: The application retrieves recorded warranty information for the selected appliance.

Repair case management: Users can create repair cases, track their status, and review case activity.

Appointment coordination: The system retrieves available technician slots and supports appointment booking with explicit user confirmation.

Cancellation recovery: The application demonstrates how a cancelled appointment can lead to an alternative slot and a confirmed rescheduling workflow.

Conversational assistance: An AI assistant supports repair-related conversations and workflow guidance, with fallback behavior when the configured agent is unavailable.

Workflow history: Repair case activity and appointment history help represent changes throughout the repair journey.

What makes FixForward AI different is its focus on the complete workflow. Rather than stopping at a troubleshooting answer, it connects user requests with structured operations and stateful repair coordination.

The current demo focuses on one simulated washing machine, the WhirlNest WashPro 8kg, identified as APL-1001. Appliance, warranty, technician, and appointment records are simulated; the application does not book real-world repair services.

How we built it

We built FixForward AI as a full-stack application with a browser-based frontend, a Python backend, persistent data storage, and an integration layer for AI tools.

Technology stack:

React and Vite: Build the interactive dashboard and conversational interface.

Python and FastAPI: Implement the REST API and core repair workflows.

SQLite: Store repair cases and appointment state.

Model Context Protocol (MCP): Expose repair coordination capabilities as tools for compatible AI clients.

AI agent integration: Support conversational assistance and tool use, including a fallback path.

Amazon Bedrock integration: Provide an integration path for the configured AI workflow when available.

Vercel and Render: Host the frontend and backend, respectively.

We designed the backend so that the browser interface and MCP tools can use the same underlying business logic. This avoids making the conversational interface the sole source of application state.

The workflow covers appliance lookup, troubleshooting, warranty retrieval, repair case creation, slot discovery, appointment booking, cancellation simulation, rescheduling, and activity history.

We also incorporated explicit confirmation into appointment operations. A proposed appointment must not be treated as a completed booking until the required user approval has been provided and the operation succeeds.

Our development approach was incremental: establish the backend business logic and MCP server, connect the browser application, and build a demonstration around a complete repair journey.

Challenges we ran into

  1. Coordinating a multi-step workflow

A repair journey involves interconnected operations. Creating a case, booking an appointment, handling cancellation, and rescheduling must work together without losing track of the case's current state.

We addressed this by implementing structured backend operations for repair cases, appointment state, and workflow activity.

  1. Making AI actions safe and predictable

An assistant should not claim that an appointment is booked merely because a user discussed a preferred time. Booking and rescheduling require explicit confirmation, and the application must distinguish a pending request from a successful operation.

We incorporated a confirmation requirement into these workflows.

  1. Integrating REST APIs with MCP

We wanted to support both a conventional web dashboard and compatible AI clients. This required exposing repair operations through REST endpoints and MCP tools while keeping the underlying business logic centralized.

  1. Connecting frontend and backend deployments

Deploying the React frontend and Python backend separately introduced configuration challenges involving API URLs, cross-origin requests, server startup, and environment variables. We had to consider these components as one application while deploying them independently.

  1. Demonstrating a realistic workflow without live service integrations

Connecting real manufacturers, warranty providers, and technician scheduling systems requires access to external services. We chose simulated records so that the core coordination workflow could be demonstrated without depending on those integrations.

This also required us to clearly distinguish simulated functionality from real-world service capabilities.

Accomplishments that we're proud of

Accomplishments that we're proud of

Built an end-to-end repair coordination foundation: The application brings troubleshooting, warranty retrieval, repair case management, and appointment workflows into one project.

Implemented stateful repair operations: Repair cases and appointment changes are represented through backend operations and SQLite-backed state.

Designed a cancellation-recovery workflow: The demo can simulate a technician cancellation and guide the user through rescheduling.

Added explicit confirmation requirements: Appointment booking and rescheduling are designed to require user approval instead of silently completing consequential actions.

Integrated MCP with the backend: Repair capabilities are exposed through MCP tools as well as REST endpoints, creating a foundation for compatible AI clients.

Built and deployed a full-stack application: The project includes a React/Vite frontend and a FastAPI backend hosted separately on Vercel and Render.

Most importantly, we are proud of the direction behind the project: combining conversational AI with structured workflows to address a practical, everyday problem.

What we learned

Building FixForward AI helped us understand that useful AI applications require more than a conversational interface.

We learned that:

Tools make AI more actionable. An assistant becomes more useful when it can interact with application services rather than only generate text.

Stateful workflows require careful design. Repair cases, appointment status, cancellation events, and rescheduling operations must remain consistent.

User confirmation is an important control. The system should distinguish between suggesting an action, requesting approval, and confirming successful execution.

MCP provides a way to expose application capabilities to compatible AI clients. It encourages us to think of the backend as reusable tools rather than functionality available only through one interface.

Reliable deployment requires full-stack thinking. Environment variables, CORS, API contracts, database persistence, and frontend error handling all affect the user experience.

Failure recovery is part of good automation. Handling a cancelled appointment is as important to the workflow as successfully creating the original booking.

The project also reinforced the importance of being transparent about what an AI system has actually done, particularly when representing external actions such as scheduling a repair.

What's next for FixForward AI

Our current implementation demonstrates the core coordination workflow using simulated data. Our next goal is to make the application more robust and move toward real-world integrations.

Planned improvements include:

Comprehensive testing: Validate the deployed frontend, backend endpoints, AI assistant, repair case lifecycle, appointment confirmation, cancellation recovery, and MCP connectivity.

Reliable persistence: Verify that important repair records survive the restarts and redeployments expected of the hosting environment.

Real warranty integrations: Explore connections to manufacturer systems to retrieve verified coverage information.

Live repair-provider integrations: Investigate connecting to actual service providers and technician scheduling systems.

More advanced agent orchestration: Improve tool selection, multi-step planning, and evidence-grounded responses.

Proactive notifications: Explore ways to inform users about appointment changes and repair progress.

Alexa+ integration: Investigate onboarding and authentication requirements as platform access permits.

Further AWS integration: Explore AWS services that can strengthen the application's AI capabilities, reliability, and scalability.

Broader appliance support: Extend the workflow beyond the initial washing-machine demonstration.

Our long-term vision is to evolve FixForward AI from a simulated repair coordination demo into a dependable assistant that helps people manage appliance issues from the first symptom through the repair process.

FixForward AI — The agent that gets things fixed.

Demo limitation: The current application uses simulated appliance, warranty, technician, and appointment records. It does not contact real repair companies or book real-world services. Planned integrations are not represented as completed features.

Built With

Share this project:

Updates

Submission history