Inspiration
My personal inspiration for this project is my grandfather's Toyota Corolla, a car that is actually older than I am and is still running today. That Corolla is a testament to reliability and trust. However, finding the financing for a new vehicle often feels anything but reliable or trustworthy. The current process is opaque and complex, creating anxiety for customers. We wanted to build a platform that matches Toyota's reputation for dependable engineering with an equally dependable, transparent, and personalized financial experience. Our goal is to make the process of securing the best deal as simple and solid as the car itself.
What it does
The Toyota Match Drive API simplifies the vehicle financing journey. It serves as the intelligent backend for a future web or mobile application, focusing on personalized financial matching and vehicle suggestion.
Financial Assessment: Accepts a user's critical data (income, credit score, desired loan term) to generate personalized payment simulations and precise financing/leasing options.
Budget-Based Matching: Based on the calculated feasible budget, the system suggests specific Toyota models from our database (Corolla, RAV4, Supra, etc.) that fit the user’s lifestyle and, crucially, their affordability.
Financial Guidance: It can eventually provide clear comparisons between financing and leasing, along with simple tips to optimize their financial decisions.
How we built it
The solution is engineered on a robust, classic three-tier architecture:
Front-end (Future): The client (web/mobile) will interact with our API.
API Layer (Application Logic): Built with Node.js and Express, this layer handles all the request routing, input validation, and the core financial matching algorithm.
Database Layer (Data Persistence): MySQL serves as the reliable data store. It hosts the crucial cars table containing our full vehicle inventory, including pricing, specs, and 3D model paths.
Deployment: The entire stack is containerized, utilizing Nginx as a powerful reverse proxy and load balancer to ensure high availability and efficient request handling.
Challenges we ran into
The primary technical hurdles involved establishing and securing the multi-layered communication pipeline:
Service Connection and Permissions: The initial setup of the stack proved challenging, specifically ensuring our Node.js application had the correct permissions to access MySQL. This resulted in persistent "Access denied for user" errors, which required deep debugging of MySQL user grants, host restrictions, and authentication methods.
API Design: Creating clean, effective API endpoints that can handle complex financial calculations efficiently and provide fast data retrieval for the car catalog.
The Matching Model: Designing the logic for the personalized matching algorithm—balancing the hard financial constraints (income/score) with the softer requirements (body type, style, interest)—was a significant intellectual challenge.
Accomplishments that we're proud of
We are most proud of establishing a fully stable and secure data pipeline:
Stable Data Flow: We successfully debugged the MySQL connection issues, transitioning from the restrictive root user to a secure, dedicated application user, resulting in a confirmed connection and data flow.
Inventory API: Successfully modeling the entire car inventory in our cars table and creating the foundational /cars endpoint that retrieves all vehicle data with speed and reliability.
Architectural Foundation: Establishing a scalable, professional three-tier architecture (Nginx, Node.js, MySQL) that is ready to support complex financial calculations and high user load.
What we learned
This project provided invaluable lessons in backend infrastructure:
Database Security: We gained a deep understanding of MySQL user management, the importance of using specific application users instead of root, and managing user grants for specific databases (the difference between accessing 'test' and accessing the intended database).
Backend Resilience: Best practices for building a production-ready API using Node.js, specifically implementing robust error handling and proper logging to quickly diagnose issues like connection failures.
Configuration Management: The necessity of using environment variables (.env) for secrets and configurations, ensuring separation between code and deployment details.
What's next for Toyota Match Drive
Our immediate next steps are focused on implementing the core value proposition:
Core Financial Engine: Our primary focus is the immediate integration of the logic to calculate personalized APRs and monthly payments based on the user's credit score and income inputs.
UI Shift to Finance: With much of the front-end vehicle display (including the 3D car models) already functional, our focus shifts entirely to building the dedicated UI for financial options. This includes presenting clear payment simulations, comparison tools, and the final financing application flow.
Advanced Matching & Filtering: We will enhance the /cars API endpoint with query parameters to allow sophisticated filtering by body_type, price, and year, further refining the budget-based matching.
Log in or sign up for Devpost to join the conversation.