90 TEN • Launch Day
0%
Launch Day workshop

From Built
to Live.

Take one small AI-powered tool from a clear idea to a connected, published, tested live experience.

Start here

Know where we’re going before we build.

Everyone will follow the same launch pathway. The project stays intentionally small so the group can focus on what usually gets skipped: powering it, publishing it, and testing the real link.

Build one useful thing.
Bring it into the world.

We are not spending today trying to invent six different apps. We are using one shared structure and making the context yours.

01Choose the version
02Customize the context
03Connect the AI power
04Deploy through Vercel
05Test the live URL
01Choose

Decide what your version transforms.

02Customize

Make the shared tool relevant.

03Connect

Give it the power it needs.

04Test

Use safe sample information.

05Deploy

Publish your own Vercel copy.

06Go live

Open and test the real link.

The shared project

Meet “Turn This Into…”

A user provides one piece of text, chooses what they want it turned into, and receives one useful AI-generated output.

One input. One transformation. One result.

The project is small on purpose. Version one should have one main input, no more than three output choices, one AI-powered result, and a simple way to copy or use it.

What it is not

Not a CRM, dashboard, database, payment system, quiz funnel, file-upload system, or complex automation. Those can come later if the simple version proves useful.

Meeting notes→next steps
Client question→helpful response
Rough idea→social post
Property details→listing description
Voice-note transcript→email
Long explanation→FAQ
Prompt 1 • Choose

Let your agent help you choose the version.

Your agent will not know what “Turn This Into…” means unless you explain the format and the guardrails first. This prompt gives it the missing context.

Copy this prompt
I’m participating in a workshop where I will build and publish a small AI-powered tool called “Turn This Into…”

Here is what that means:

A user provides one piece of text, chooses what they want it turned into, and receives one useful AI-generated output.

Examples include:
- Meeting notes turned into next steps
- A client question turned into a helpful response
- A rough idea turned into a social post
- Property details turned into a listing description
- A voice-note transcript turned into an email
- A long explanation turned into an FAQ
- A messy brain dump turned into a clear plan
- A service description turned into a simple sales blurb

The tool should stay intentionally small. Version one should have:
- One main text input
- No more than three transformation options
- One clear AI-generated result
- A copy button or simple way to use the result
- No CRM, database, payment system, quiz funnel, dashboard, file-upload system, or complex automation

My business is: [describe your business].
My audience is: [describe who you help].
The type of content my audience commonly creates, receives, or struggles to organize is: [describe it].

Help me decide what specific version of the “Turn This Into…” tool would be most useful for my audience.

Give me three possible versions. For each one, include:
1. What the user would paste into the tool
2. What the tool would turn it into
3. Why this would be useful
4. Three possible transformation options
5. How simple it would be to build and test
6. What we should leave out of version one

Then recommend the strongest option based on usefulness, simplicity, and how easy it will be to connect, publish, and test live.

Do not recommend a completely different type of app. Keep the idea inside the “Turn This Into…” format.
Usefulness

Would people actually use this transformation?

Simplicity

Can we build it during the workshop?

Live testability

Can we connect, deploy, and verify it?

Your decision

Your agent recommends. You choose the version.

Prompt 2 • Define

Now make the chosen version clear.

This prompt does not choose a new project. It refines the version you already selected so it stays small enough to build, connect, publish, and test.

Copy this prompt after choosing
I’ve chosen this version of my “Turn This Into…” tool:

[describe the chosen version]

Help me define the version-one build clearly.

Create:
- A simple tool name
- A one-sentence description
- The main input instructions
- No more than three transformation options
- A short instruction for the AI’s tone and style
- What the result should include
- A helpful next step after someone gets the result
- One feature we should intentionally leave out for now

Keep this small enough to build, connect, publish through Vercel, and test during a workshop.
Step 3 • Connect

Give the tool the power it needs.

A tool can look finished and still have no power behind it. This is where you connect the AI source through your own account without putting a private API key into the public app.

The three layers

Interface

What people see and interact with.

AI connection

What generates the response.

Hosting

Where the live tool lives.

Connection prompt
I’m connecting the AI power for my “Turn This Into…” tool.

Explain:
- What this connection powers
- What information the tool sends
- What comes back
- Whether anything is stored
- What could create usage costs
- What I should test before publishing
- What I should never expose in the public version
Create the API connection
  1. Sign in to OpenAI Platform. Go to platform.openai.com, not the regular ChatGPT conversation or LLM chat area.
  2. Create the OpenAI API key or project connection that will power the published tool.
  3. Save/connect that API key in 90 TEN’s approved secret or AI power flow. Do not paste the raw key into the tool’s HTML, JavaScript, GitHub, or Vercel client-side code.
  4. Have the tool call the 90 TEN AI proxy at /api/micro-ai. The proxy keeps the private API key away from the public app.
  5. Test in preview with the token blank. Your signed-in ChatGPT OAuth connection can help you build and preview inside 90 TEN, but the public Vercel version still needs the OpenAI Platform API connection.
  6. Open the app’s AI power panel. Choose the connected OpenAI API power and set the public usage limit or spending cap.
  7. Generate the public tool token and paste that token into the app’s token field or configuration. The token gives the published tool permission to use the API connection. It is not your ChatGPT login or private API key.
  8. Run a fake or low-risk sample, then deploy to Vercel and test the live URL as a first-time user.

Public token breakdown

  1. The OpenAI Platform API connection is the power source for the public tool. It stays behind the 90 TEN proxy and is not copied into the public app.
  2. The AI power panel creates a controlled bridge. It lets the published tool request AI help through the connection you selected.
  3. The public tool token is the permission slip. It tells the proxy which published tool is allowed to make requests. It is not your ChatGPT password, OAuth code, or private API key.
  4. The spending or usage limit is the boundary. Set it before publishing so the public tool has a defined limit.
  5. The token goes into the tool’s token field or configuration. That is the only value the public version needs. Never paste your ChatGPT login or provider key there.
  6. Test the token before you deploy. Run one fake sample, confirm the tool returns a result, then deploy and test the live Vercel URL separately.

Important distinction: ChatGPT chat and OpenAI Platform are separate places. Sign in to platform.openai.com for the required OpenAI API connection, not the regular ChatGPT conversation or LLM chat area. ChatGPT OAuth can help you build and preview; the OpenAI Platform API connection powers the published tool.

Never do this

Do not put the private key in:

Public HTML, client-side JavaScript, a GitHub repository, a screenshot, a prompt someone else will copy, or a Vercel environment value that is exposed to the browser.

Do use:

The required OpenAI Platform API connection, the 90 TEN AI proxy, a capped public token, fake test data, and a live-link test after deployment. ChatGPT OAuth can support building and previewing, but it does not replace the public API connection.

Steps 4–6 • Launch

Test it. Deploy it. Open the real link.

The AI connection powers the tool. Vercel publishes the tool. The live URL is where you find out whether the whole experience actually works.

01Run a safe sample testUse fake or low-risk content.
02Configure the connectionKeep private keys out of the public code.
03Deploy your own copy to VercelEach person uses their own account.
04Find the live Vercel URLOpen it outside the builder.
05Test as a first-time userPreview success is not launch success.
Vercel publishing prompt
I’m ready to publish my “Turn This Into…” tool through Vercel.

Create a simple deployment checklist for me.

Include:
- What files need to be included
- What connection or environment settings need to be configured
- How to make sure private keys are not exposed
- How to confirm the deployment succeeded
- How to find the live URL
- What I should test immediately after opening the live link
Live-link testing prompt
Here is my live Vercel link: [paste link]

Help me test it as a first-time user.

Check:
- Does the page explain what it does?
- Is the first action obvious?
- Does the AI connection work?
- Does each transformation produce the expected kind of result?
- Are errors understandable?
- Does the live version behave differently from the preview?
- Is it ready to share?

Give me only the three most important findings.
Your launch checkup

Know what is true before you share it.

Use this as your final pass. The checkboxes save in this browser so you can pause, replay, and pick back up without losing your place.

Launch readiness

Mark the things you have actually verified, not the things you hope are working.

Autosave on
After launch

Decide what happens next.

Publishing is not a promise that the tool has to live forever. It is a way to learn whether the small thing is useful.

Share it

The live flow works and the purpose is clear.

Revise one thing

One focused fix would make it meaningfully better.

Keep it private

You need more confidence before sharing publicly.

Pause or retire

It no longer solves a real problem.

You do not need a huge app to launch something real. One useful input. One helpful output. One live link.
Prompt copied