Inspiration
Handly began with a problem I have experienced personally: finding reliable and fairly priced contractors in Europe can be surprisingly difficult. Good professionals are often fully booked, quotations vary enormously, and customers rarely have enough information to determine what a reasonable price should be. As an immigrant, this uncertainty is even greater. You may not understand the local pricing norms, know which qualifications matter, or have a trusted network from which to ask for recommendations.
Most existing platforms help customers discover contractors, but discovery is only the beginning of the problem. Customers still need to define the work, understand the likely cost, compare offers, communicate safely, manage changes, and verify what was completed. Contractors also need something better than low-quality leads and vague requests.
I built Handly to make that entire process more structured and transparent. The goal is to combine the convenience of an on-demand marketplace with the project intelligence needed for more complicated home repairs.
What it does
Handly is a trust-first, cross-platform marketplace for home services. It supports two different workflows because not every job should be treated the same way.
Standardized services can be booked directly using defined prices and real availability. More complex work follows a quotation process in which the customer can create a structured project report, select professionals, receive proposals, and compare them side by side.
The central feature is Smart Scope, which turns a customer’s description into an initial assessment of the work, expected duration, likely price range, and possible safety concerns. It is deliberately designed as an assistant rather than an authority. A professional remains responsible for confirming the final scope and price, while potentially dangerous situations are escalated instead of being pushed into an unsafe booking flow.
Once a project begins, the Job Room becomes the shared record between the customer and professional. It brings together the accepted scope, quotations, messages, scheduling, change orders, arrival information, before-and-after evidence, completion approval, reviews, and warranty cases. This reduces the misunderstandings that often happen when details are spread across phone calls, messages, and paper quotations.
Handly also includes Home Health, which allows customers to build a long-term record of their property, including previous jobs, appliances, invoices, warranties, maintenance reminders, and preferred professionals. The aim is to turn isolated repairs into an understandable history of the home.
How we built it
I built most of Handly myself, using Codex powered by GPT-5.6 Sol as a continuous engineering collaborator. My teammate primarily provided oversight, challenged decisions, and helped optimize the product and development direction.
The project includes a responsive React and TypeScript web application, a Node.js API, SQLite persistence, a native Android client built with Kotlin and Jetpack Compose, and an iOS codebase written in Swift and SwiftUI. All clients are designed around the same backend contracts instead of maintaining separate versions of marketplace data and business rules.
A major architectural decision was to make the server authoritative. Clients can display provisional availability or calculate an estimated price, but the backend owns the accepted time slot, final amount, booking state, permissions, and lifecycle transitions. Expiring slot holds, transactional booking, idempotency controls, and conflict prevention help protect against stale prices and double bookings.
The prototype also includes authenticated accounts, synchronized messaging and notifications, vendor verification boundaries, consent-based contact sharing, quote calibration, service evidence, role-based actions, audit records, and explicit integration points for payments, file storage, push notifications, identity verification, and protected calling. Integrations that do not have real credentials are presented honestly as unavailable or demonstrational rather than pretending that an external action occurred.
Testing covered domain logic, API behavior, complete browser journeys, accessibility, synchronization, booking conflicts, safety escalation, and failure cases. The consolidated version passed its web tests, API integration tests, production build, and Playwright end-to-end scenarios.
Challenges we ran into
The largest challenge was the scope. I was not building only a polished interface; I was trying to make the web application, backend, Android application, and iOS foundation behave like parts of the same product. A rule changed in one place could affect data contracts, database behavior, user interfaces, tests, and two native clients.
Time was also limited, while my private life was unusually chaotic because I was moving internationally during development. That made prioritization essential. I had to distinguish between features that looked impressive and foundations that actually made the marketplace trustworthy.
iOS was the most difficult platform. I do not own or have access to a macOS or iOS-compatible device, so I could not compile, sign, launch, or visually validate the application through Xcode or on a simulator or physical device. The repository contains a substantial SwiftUI client and shared iOS implementation, but I consider it an unverified foundation rather than a tested deliverable. The web experience received the strongest validation, followed by Android.
Another challenge was consolidating parallel development branches that had evolved different solutions for bookings, notifications, quotations, and database structures. Merging them mechanically would have introduced subtle inconsistencies. I instead had to compare their behavior, choose authoritative implementations, preserve complementary features, and explicitly migrate incompatible data structures.
Accomplishments that we're proud of
We are especially proud that Handly became much more than a visual marketplace prototype. Within a limited development period, we built a working foundation spanning a responsive React web application, a Node.js backend, persistent database infrastructure, a native Android application, and a substantial—although not yet device-tested—iOS codebase.
Our biggest product accomplishment is creating a repair journey that addresses more than contractor discovery. Handly helps users define their problem through Smart Scope, understand likely prices and safety concerns, request and compare structured quotations, and manage the selected contractor through a shared Job Room. This creates a clear record of the agreed scope, communication, scheduling, changes, evidence, completion, reviews, and warranty issues.
We are also proud of the technical foundations beneath the experience. The backend acts as the authoritative source for pricing, availability, permissions, and booking status. Transactional booking, expiring slot holds, conflict prevention, idempotency controls, and synchronized client contracts make the prototype behave like the foundation of a real marketplace rather than a collection of disconnected screens.
Trust and safety were treated as core requirements. The system establishes boundaries for contractor verification, escalates potentially dangerous repair situations, keeps AI-generated assessments provisional, and leaves final technical decisions to qualified professionals. Features without active third-party credentials are clearly identified as demonstrations instead of presenting simulated integrations as real actions.
The consolidated web application passed its production build, API integration tests, end-to-end browser journeys, booking-conflict tests, safety-escalation scenarios, synchronization checks, and accessibility validation.
On a personal level, building Handly is something I am deeply proud of. I am a self-taught coder and developed most of the project while moving internationally and dealing with significant time constraints. Codex and GPT-5.6 Sol allowed me to concentrate on product creation while working through architecture and implementation challenges that I previously could not have handled alone. My teammate provided oversight, challenged decisions, and helped optimize the product direction.
What we learned
I am a self-taught coder, but before this project I would not have described myself as highly proficient. What I have always enjoyed most is creation: imagining how a product should work, understanding the people it serves, and turning disconnected ideas into a coherent system.
Building Handly taught me how cross-platform products must be designed around shared contracts and authoritative sources of truth. I learned much more about database optimization, transactional state, idempotency, API boundaries, native application structures, test-driven iteration, accessibility, and the difficulty of keeping multiple clients synchronized.
Most importantly, Codex changed what I was capable of building. It allowed me to focus on product creation while still engaging seriously with architecture, security, testing, and implementation. It did not replace judgment: I still had to define the problem, decide what should exist, review outcomes, identify unsafe assumptions, and choose between competing approaches. But it removed much of the technical distance between an idea and a working system.
What's next for Handly
The immediate priority is converting Handly from a technically strong prototype into a production-ready pilot. This includes connecting live payment processing, identity and contractor verification, protected file storage, push notifications, and privacy-preserving communications.
The iOS application also requires dedicated validation. Because we did not have access to macOS, an iPhone, or an iOS simulator during development, the existing SwiftUI implementation still needs to be compiled, tested, visually reviewed, and refined on supported hardware.
We then plan to work with homeowners and repair professionals to validate the complete journey. Their feedback will help us improve Smart Scope, calibrate regional price estimates, simplify quotation comparison, and determine which categories are suitable for direct booking versus professional inspection.
Longer term, we want to expand Home Health into a persistent maintenance record for each property. Repairs, appliances, warranties, invoices, recurring maintenance, and trusted professionals could become part of a continuously updated digital history of the home.
Our goal is not to automate professional judgment. It is to give customers and contractors a clearer, safer, and more transparent way to understand work, agree on expectations, and manage repairs from the first photograph to final approval.
Log in or sign up for Devpost to join the conversation.