Inspiration

The Origin of NVP

1. The Search

I began looking for a new vehicle to replace my aging car.

Like many buyers, I turned to ChatGPT for help with:

Contacting dealerships
Understanding industry jargon
Reviewing offers
Checking whether my targets were realistic
Drafting negotiation responses

ChatGPT helped separate a strong negotiation strategy from an unrealistic fantasy number.

2. The Problem

The advice was useful, but the process quickly became messy.

There was constant copying and pasting between:

Dealer emails
Text messages
Offer sheets
Vehicle details
Negotiation drafts
Multiple dealership conversations

Each dealer had a different offer, different terms, and a different stage in the negotiation.

Before long, the process became difficult to organize and compare.

3. The Insight

The real problem was not a lack of information.

It was the lack of one organized place to manage:

[ \text{Dealers} + \text{Messages} + \text{Offers} + \text{Targets} + \text{Documents} ]

ChatGPT could help analyze each piece, but the buyer still had to manually manage the entire negotiation.

4. The Idea

That experience became the foundation for NVP — New Vehicle Purchase.

NVP was designed to bring the full car-buying negotiation into one structured workspace.

Instead of juggling multiple conversations and spreadsheets, the buyer can:

Track every dealer
Save each offer
Compare terms
Store vehicle details
Set negotiation targets
Generate stronger replies
Know when a deal is worth acting on

5. The Vision

NVP turns a hectic car search into a clear decision-making process.

[ \text{Messy Negotiation} \rightarrow \text{Organized Workspace} \rightarrow \text{Smarter Decision} ]

NVP was born from a real car-buying problem: too many dealers, too many messages, and no simple way to see the whole deal.

What it does

Project Story: NVP — New Vehicle Purchase

1. The Problem

Car buying is fragmented.

Dealer emails, text messages, screenshots, lease worksheets, trade values, incentives, and target prices all live in different places. Buyers often focus on the monthly payment while hidden costs quietly change the real deal.

A simple-looking offer can be misleading:

[

\text{True Cost}

\text{Payments} + \text{Down Payment} +

\text{Fees}

\text{Incentives}

\text{Trade Value} ]

The goal was to create one place where the buyer can see the whole negotiation clearly.

2. The First Solution

NVP began as a lightweight negotiation workspace.

Each vehicle and dealer gets its own workspace containing:

Messages
Offers
Vehicle details
Buyer targets
Files and screenshots
Reply templates
Deal history

The app turns a messy negotiation into a structured process.

3. The Mobile Experience

The interface evolved into a mobile-first workflow:

[ \text{Home} \rightarrow \text{Workspace} \rightarrow \text{Action} \rightarrow \text{Decision} ]

A buyer can quickly:

Review the latest offer
Draft a reply
Enter new numbers
Compare dealers
Check missing details
See the next recommended action

The design uses the NVP Premium Slate theme: clean white surfaces, slate structure, red accents, and clear success indicators.

4. AI as an Assistant, Not the Decision-Maker

AI was added to help with repetitive work:

Extract offer details from screenshots and PDFs
Interpret vehicle information
Improve negotiation messages
Compare offers
Identify missing terms

AI results are cached, so repeated work does not create unnecessary cost.

The guiding rule is:

[ \text{AI supports the buyer} \neq \text{AI blindly controls the deal} ]

Manual entry and rule-based features remain available without AI.

5. Subscription and Cost Controls

The app now supports tier-based access:

Free

Basic workspace and manual negotiation tools.

Negotiation Pass

AI reply assistance, document extraction, and offer comparison.

Pro

Higher AI usage limits and future advanced features.

AI actions consume credits based on complexity:

[ C_{\text{reply}}=1,\quad C_{\text{compare}}=2,\quad C_{\text{extract}}=3 ]

Failed requests, cached results, duplicate requests, and placeholder responses cost:

[ C=0 ]

6. The Deal Alert Engine

The app now evaluates every offer against the buyer’s saved targets.

Possible outcomes include:

Better Than Target
Target Met
Near Target
Review Needed
Not Qualified

The engine checks more than the payment. It considers available information such as price, down payment, term, kilometres, fees, vehicle match, and missing details.

A simplified score is:

[

\text{Deal Score}

\frac{\sum w_i s_i}{\sum w_i} \times 100 ]

where:

(w_i) is the importance of each criterion
(s_i) is how well the offer satisfies it

When a deal reaches the target, NVP highlights it immediately so the buyer can act before the opportunity disappears.

7. Where the Project Is Going

The next stage transforms NVP from a single-user negotiation tool into a full platform:

Secure user accounts
User-owned workspaces and data
Database-backed storage
Gmail conversation integration
SMS negotiation channels
Multi-dealer campaigns
Approval-based automated replies
Controlled autonomous negotiation

The long-term vision is simple:

Tell NVP the exact vehicle and deal you want. Let it organize the conversations, compare every offer, and alert you when it is time to close.

How we built it

Building NVP Without Being a Coder

1. Starting With an Idea

I was not a traditional software developer, but I had a clear goal:

Build an application that could simplify the car-buying and negotiation process.

I started with a ChatGPT Plus subscription and used it as a guide to turn the idea into something practical.

2. Learning the Foundation

ChatGPT helped me understand what tools were needed and how the application should be structured.

That included guidance on:

Installing Python
Setting up the development environment
Organizing the frontend and backend
Running the application locally
Troubleshooting errors
Choosing a realistic proof-of-concept architecture

Rather than starting with a full production database, I chose Excel for the first version.

[ \text{Simple POC} < \text{Complex Production System} ]

The goal was to prove that the workflow could work before investing in heavier infrastructure.

3. Building the First MVP

Through a lot of back-and-forth, ChatGPT helped me:

Define the application structure
Build the first screens
Create the backend
Connect the app to Excel
Store dealers, vehicles, messages, offers, and targets
Troubleshoot setup and coding issues

Eventually, the first working MVP was ready.

The idea had become a real application.

4. Moving From Copy-and-Paste to Codex

The next breakthrough came when I asked whether Codex could take over more of the coding work.

Until that point, I was manually copying code from ChatGPT into the project.

Codex changed the workflow:

[ \text{Idea} \rightarrow \text{ChatGPT Prompt} \rightarrow \text{Codex Implementation} \rightarrow \text{Working Feature} ]

ChatGPT helped translate my business ideas into precise technical instructions that Codex could follow.

5. Where the Magic Happened

This became the most powerful part of the process.

I would explain to ChatGPT:

What I wanted changed
What was not working
What looked wrong
What behavior I expected
What errors appeared

ChatGPT would then create a detailed prompt for Codex.

I would copy that prompt into Codex, wait for the implementation, and review the result.

When something went off track, the cycle repeated:

[ \text{Observe} \rightarrow \text{Explain} \rightarrow \text{Prompt} \rightarrow \text{Implement} \rightarrow \text{Improve} ]

6. The Real Advantage

The biggest advantage was not that AI wrote code for me.

It was that AI helped bridge the gap between:

A business idea
A user experience problem
A technical implementation

ChatGPT became the translator.

Codex became the builder.

I remained the product owner, tester, and decision-maker.

7. The Lesson

NVP proved that someone without a traditional coding background can still build a functional application by combining:

Clear ideas
Iterative testing
ChatGPT guidance
Codex implementation
A willingness to learn

The real magic was not replacing the developer. It was giving a non-developer the tools to think, direct, test, and build like one.

Challenges we ran into

Challenges Along the Way

1. Setting Up the Right Foundation

One of the first challenges was figuring out the minimum set of accounts, tools, and services needed to build the application.

That meant understanding what was actually necessary for the proof of concept and what could wait until later.

The goal was to avoid overcomplicating the setup while still creating a foundation that could grow.

[ \text{Minimum Setup} \rightarrow \text{Working Prototype} \rightarrow \text{Future Expansion} ]

2. Learning to Work With the Terminal

Another major challenge was learning how to use the terminal commands provided by ChatGPT.

This included:

Activating the Python environment
Starting the backend
Running the frontend
Installing dependencies
Running tests
Switching Git branches
Pulling and validating changes
Understanding error messages

Even small typing mistakes could stop the process.

Commands such as:

python -m pytest

could behave very differently from:

python - m pytest

Over time, the terminal became less intimidating and more like a validation tool.

3. Balancing Speed and Security

I was also cautious about sharing too much information too early.

That caution slowed development at times, but it was intentional.

I wanted to control:

What data was stored
Which files were committed
Where API keys were kept
What Codex could modify
Which folders were considered safe
Whether local data could accidentally reach GitHub

This often meant adding extra safeguards, backups, protected-file rules, and manual validation steps.

[ \text{Development Speed} \quad \text{vs.} \quad \text{Security Confidence} ]

The process was slower, but it gave me greater confidence in the project.

4. Managing Codex Credit Limits

Another practical challenge was running out of Codex credits during development.

When that happened, work had to pause until the credits reset.

That forced me to become more deliberate about each request.

Instead of sending many small or unclear instructions, I learned to prepare more complete prompts that included:

The exact goal
The branch to use
Files that must not be touched
Validation requirements
Expected behavior
Required test results
What to report afterward

This improved the development workflow.

[

\text{Better Prompt}

\text{Fewer Iterations} + \text{Less Wasted Credit} ]

5. Learning Through Errors

Many challenges came from unexpected errors:

Missing dependencies
Incorrect virtual environments
Git credential failures
Patch conflicts
Build issues
Branch synchronization problems
Small command-line typos

Each issue became part of the learning process.

The workflow gradually became:

[ \text{Error} \rightarrow \text{Understand} \rightarrow \text{Correct} \rightarrow \text{Document} \rightarrow \text{Avoid Repeating} ]

6. The Outcome

The challenges slowed the project at times, but they also made the application and the development process stronger.

I learned how to:

Protect important files
Create recovery points
Validate code locally
Manage branches
Interpret test results
Give clearer instructions
Separate proof-of-concept decisions from production decisions

The hardest part was not writing code. It was learning how to safely guide, validate, and manage an AI-assisted development process.

Accomplishments that we're proud of

Accomplishments and Milestones

1. Building a Custom Application

The biggest accomplishment was turning an idea into a working custom application.

I did not begin as a traditional software developer. Instead, I used ChatGPT and Codex as my AI-powered development and operations team.

Together, they helped me:

Shape the product vision
Design the application structure
Build features
Troubleshoot problems
Validate changes
Manage releases and recovery points

[ \text{My Vision} + \text{ChatGPT Guidance} +

\text{Codex Execution}

\text{Working Application} ]

That was a game changer.

2. Learning PowerShell

At the beginning, the Windows PowerShell terminal felt unfamiliar and intimidating.

Over time, I learned how to use it to:

Start the frontend and backend
Activate Python environments
Install dependencies
Run automated tests
Manage Git branches
Pull and validate changes
Create backups
Diagnose errors

Commands stopped feeling like random instructions and became tools I could understand and use with confidence.

3. Understanding Development Practices

Building NVP also gave me a practical view into how software-development teams may work.

I learned the purpose of:

Feature branches
Commits and merges
Protected files
Unit tests
Full test suites
Frontend builds
Smoke testing
Backup tags and recovery branches
Development versus production configurations

The development cycle became:

[ \text{Build} \rightarrow \text{Test} \rightarrow \text{Review} \rightarrow \text{Merge} \rightarrow \text{Validate} ]

I was not just seeing the final product—I was learning how reliable software is delivered.

4. Improving the Original Ideas

Another major accomplishment was learning when my first idea was not necessarily the best approach.

ChatGPT regularly helped me consider:

Simpler proof-of-concept options
Safer implementation methods
Better user experiences
More realistic pricing structures
Security and privacy concerns
Subscription and AI-credit controls
Scalable architecture for future growth

Instead of simply agreeing with my initial direction, it often presented stronger alternatives and explained the trade-offs.

5. Becoming the Product Owner

As the project developed, my role became clearer.

ChatGPT helped with strategy and translation.

Codex handled much of the technical implementation.

I remained responsible for:

Defining the problem
Setting priorities
Reviewing the experience
Identifying defects
Approving changes
Testing results
Protecting the project’s direction

[ \text{AI Builds Faster} +

\text{Human Judgment}

\text{Better Product} ]

6. The Bigger Achievement

The real accomplishment was not simply building an app.

It was learning that I could:

Turn a personal problem into a product idea
Guide an AI-assisted development process
Understand enough technology to validate the work
Make informed architecture and security decisions
Build something increasingly sophisticated without a traditional coding background

NVP showed me that I did not need to become a full-time coder to become a capable builder. I needed a clear vision, the right tools, and the willingness to keep learning.

What we learned

What I Learned

1. AI Is Only as Good as the Direction It Receives

ChatGPT can help shape ideas, solve problems, and guide development—but the quality of the outcome depends heavily on the quality of the prompt.

A vague request often produces a vague result.

A clear request produces something much more useful.

[ \text{Better Prompt} \rightarrow \text{Better Context} \rightarrow \text{Better Outcome} ]

I learned to explain:

What I wanted
Why I wanted it
What should not change
Which files were protected
How the feature should behave
How the result should be tested

2. Prompting Became Part of the Build Process

Prompting was not just asking a question.

It became part of the product-development workflow.

A strong prompt needed to include:

The business goal
The technical constraints
The expected user experience
Validation requirements
Security boundaries
What Codex should report afterward

This helped reduce misunderstandings and unnecessary rework.

3. Codex Removed Much of the Manual Effort

Codex saved a significant amount of time by handling the actual implementation work.

Instead of manually copying and pasting code file by file, Codex could:

Update multiple files
Create new components
Add backend routes
Write tests
Run builds
Commit changes
Push branches

That changed the development equation:

[ \text{Manual Coding Effort} \downarrow \qquad \text{Review and Direction} \uparrow ]

My role shifted from typing every change to guiding, reviewing, and validating the work.

4. Codex Still Needs Boundaries

Without full free rein, Codex needs clear guidance.

That guidance is important because it helps protect:

Existing features
Local data
Workbook files
Environment secrets
Runtime data
Git history
The intended user experience

I learned that giving Codex more context upfront was safer than asking it to make broad changes with limited direction.

5. ChatGPT Became the Translator

One of the biggest lessons was how effective ChatGPT was at translating my ideas into technical instructions.

I could describe a problem in plain language, such as:

“The screen feels too crowded.”
“This feature should be locked for Free users.”
“The app should alert me when the deal hits my target.”
“Do not let this change affect the workbook.”

ChatGPT would then turn that into a structured prompt Codex could act on.

[ \text{Human Idea} \rightarrow \text{ChatGPT Translation} \rightarrow \text{Codex Implementation} ]

6. The Best Results Came From Collaboration

Neither tool worked best in isolation.

ChatGPT was strongest at:

Clarifying the problem
Challenging assumptions
Planning the approach
Writing precise prompts
Explaining errors

Codex was strongest at:

Editing the codebase
Implementing features
Updating multiple files
Running technical validation
Managing branches and commits

I learned that the real power came from using both together.

7. The Main Lesson

The biggest takeaway was that AI-assisted development is not fully automatic.

It still requires:

Clear thinking
Good judgment
Specific instructions
Careful review
Testing
Security awareness

ChatGPT helped me say exactly what needed to be built, while Codex helped turn those instructions into working software. The better I became at guiding them, the better the application became.

What's next for Car Negotiation App

What’s Next for NVP

1. Helping Buyers Get More Value

The next step is to move NVP from a personal proof of concept into a tool that can help more people get the best possible deal.

The goal is simple:

Help buyers save money, avoid hidden costs, and get more value for every dollar they spend.

NVP should make the negotiation process easier, clearer, and more confident.

2. Bringing Communication Into One Place

Today, buyers may still need to copy and paste between:

Email
SMS
Dealer websites
The NVP workspace

The next evolution is to connect those communication channels directly to the app.

[ \text{Email} + \text{SMS} + \text{Dealer Replies} \rightarrow \text{One NVP Workspace} ]

This would remove much of the manual work and reduce the risk of losing important details.

3. Email Integration

With email connected, NVP could:

Import dealer conversations
Match emails to the correct vehicle workspace
Extract offer details
Identify missing information
Suggest the best response
Track the full negotiation history
Alert the buyer when a target is reached

Instead of searching through multiple inbox threads, the buyer would see the entire negotiation in one place.

4. SMS Integration

SMS integration would bring dealer text conversations into the same workflow.

NVP could help:

Capture inbound messages
Organize replies by dealer
Suggest or prepare responses
Detect new offers
Compare updated terms
Keep a complete communication record

This would make the app more useful during fast-moving negotiations, where important offers may arrive by text.

5. Assisted Negotiation

The application could support different levels of control.

Draft Mode

NVP prepares the strongest response, but the user sends it manually.

Approval Mode

NVP prepares the response and asks the user to approve it before sending.

Controlled Automation

NVP responds automatically only within strict rules defined by the buyer.

[ \text{Buyer Criteria} + \text{Dealer Response} +

\text{Negotiation Rules}

\text{Recommended Action} ]

The user should always remain in control of important commitments.

6. Managing Multiple Dealers

A major future feature is the ability to negotiate with several dealers at the same time.

NVP could:

Send consistent inquiries
Track separate conversations
Normalize every offer
Compare total costs
Rank the best deals
Highlight missing terms
Present the strongest finalists

This would turn a confusing dealer search into a structured competition for the buyer’s business.

7. The Long-Term Vision

The long-term goal is for the buyer to describe the exact vehicle and deal they want.

For example:

Specific make, model, trim, and colour
Maximum monthly payment
Maximum down payment
Odometer limit
Required features
Preferred term
Trade-in expectations

NVP would then help manage the process from first contact to final comparison.

[ \text{Buyer Goal} \rightarrow \text{Dealer Negotiations} \rightarrow \text{Offer Comparison} \rightarrow \text{Best Deal} ]

The future of NVP is one place to manage every dealer, every message, and every offer—so the buyer can focus on getting the best bang for their buck.

Built With

chatgpt
codex
css
excel
fastapi
git
github
html
javascript
jsx
phython
powershell
react
uvicorn
visual-studio-code
vite