Utopia Homes

The product

Utopia Homes was a US real-estate startup building a rent-to-own platform to help renters work toward homeownership. The product brought together property discovery, applicant onboarding, underwriting, document management, and internal administration.

As a founding software engineer, I built the customer-facing platform and its supporting operational systems. My work covered the Next.js frontend, Node.js backend, Firebase integration, underwriting system, administration tools, and deployment on Vercel.

I worked closely with the founding team to translate the business’s requirements into a working product, taking responsibility across architecture, implementation, integration, and release.

The project ran from October 2022 to November 2023. It is represented here as historical because the original domain and internal systems are no longer publicly available.

Purpose

Utopia Homes aimed to help people pursue homeownership through a rent-to-own model.

The platform supported the journey from finding a suitable property to completing an application and progressing through assessment. It also provided the internal tools needed to review applicants, manage supporting documents, and coordinate the underwriting process.

This required building both the experience prospective homeowners used and the systems the team relied on to manage their applications.

Property listings and discovery

I built the property-listing and discovery functionality using Next.js, connecting the interface with the backend and Firebase data layer.

Users could browse homes, review property details, and narrow their search through filtering. These features connected property discovery with the application process.

The functionality included:

• Property listings and detail pages.
• Search and filtering.
• Property-information presentation.
• Connections between property selection and applicant onboarding.
• Administrative tools for managing listings.

Applicant onboarding and applications

I built the onboarding and application workflows for prospective homeowners.

These flows collected applicant information and made it available to the systems supporting assessment and administration. The implementation covered the frontend forms, backend processing, data integration, and internal interfaces for reviewing applications.

The work required keeping information consistent between what applicants submitted and what the operations team accessed.

Underwriting system

I built the underwriting system used to support the rent-to-own assessment process.

This connected applicant information, supporting documents, and internal review workflows. I worked with the founding team to translate their underwriting requirements into application logic and administrative functionality.

The underwriting system was integrated with the broader platform, allowing the team to work with information collected through onboarding and manage applications as they progressed through assessment.

Document management

I built document-management functionality for collecting and organizing material associated with applications.

This connected supporting documents with the relevant applicant information and made them available within the internal review process.

The work covered the user-facing document experience and the administrative functionality needed to access and manage that information.

Administration and operational tools

I built the administration interfaces used to manage the platform’s day-to-day operations.

These tools connected the customer-facing application with the work performed by the internal team. They covered:

• Property and listing management.
• User and applicant management.
• Application review and oversight.
• Underwriting workflows.
• Supporting-document management.
• Operational dashboards.

Building both sides of the product allowed me to coordinate the applicant experience with the team’s internal processes.

Analytics and dashboards

I developed dashboards to give the team visibility into application activity and operational information.

These interfaces brought relevant data together for reviewing applications and managing ongoing work. They formed part of the administration experience and supported the team’s use of the platform.

Next.js frontend

The frontend was built with Next.js and React, using TypeScript and Redux as part of the application stack.

I developed the customer-facing pages and internal administration interfaces, including property discovery, onboarding, application forms, document workflows, and dashboards.

My work covered component development, application state, backend integration, and the behavior connecting these features.

Node.js backend

I built the backend using Node.js.

The backend handled application logic and connected the frontend with Firebase and the platform’s supporting functionality. It supported the workflows behind property listings, applicant information, underwriting, documents, and administration.

My responsibilities included developing the backend functionality and integrating it with the frontend so the different parts of the product worked together.

Firebase integration

Firebase was the primary backend platform and was used extensively throughout the application.

I integrated Firebase with the Next.js frontend and Node.js backend to support the platform’s data and application workflows. It formed a central part of the system behind both the customer experience and the internal operational tools.

The majority of my development work on Utopia Homes was carried out on this Firebase-based architecture.

Deployment on Vercel

I deployed the application on Vercel and managed delivery of application updates.

This extended my ownership beyond feature implementation into release preparation and deployment. I worked across the development lifecycle, from translating requirements into code to making changes available in the deployed application.

Supabase migration

Later in the project, we began transitioning toward Supabase.

I worked on the application during this migration, but the Supabase integration was not complete when I left. Firebase remained the primary backend platform throughout my involvement.

Technology stack

My responsibilities

• Built the platform as a founding software engineer.
• Developed the Next.js frontend and Node.js backend.
• Integrated Firebase throughout the application.
• Built property listings, search, filtering, and discovery.
• Developed applicant onboarding and application workflows.
• Built the underwriting system.
• Implemented document-management functionality.
• Created administration tools and operational dashboards.
• Deployed the application on Vercel.
• Worked on the later transition toward Supabase.
• Collaborated with the founding team on requirements, architecture, and product delivery.

Key engineering challenges

The main challenge was connecting a property-discovery product with the application and underwriting processes behind it. Information needed to move consistently from customer-facing forms into internal review tools, with documents and applicant records available where the team needed them.

Building the entire platform also required balancing user-facing development with operational functionality. Each customer workflow needed corresponding backend logic, data handling, and administrative support.

As the startup’s requirements evolved, I worked across these layers to keep the product aligned with the business process. The later Supabase migration introduced additional work while the existing Firebase-based application continued to serve as the primary system.

Delivered scope

I built Utopia Homes’ property-discovery experience, applicant onboarding, underwriting system, document management, and administration tools using Next.js, Node.js, and Firebase, with deployment on Vercel.

The project reflects my experience taking broad engineering ownership in an early-stage startup, building both the customer-facing product and the internal systems needed to operate it.

Links and status

Utopia Homes is kept as a historical project. The original public domain is no longer used as a live demo, and no current public product link is included here. The page describes my reported implementation scope and does not present underwriting decisions, housing outcomes, or production availability as an independent audit.