Build Like a Baddie: Build Your Own AI Model
Mini Blog Course
By Ya'mia Oshun Porter — CEO of BBAIS LLC · 2026-10-10
I mentioned in the Baddies of AI group that you can host your own AI model, and 86 of you slid into my messages asking how. This is my exact method, step by step and in plain language: Claude Code, Modal, Hugging Face, and Render, from your first account to naming your model. Plus the real cost of owning one, with the math done for you.
Build Like a Baddie: Build Your Own AI Model
By Ya'mia Oshun, CEO — BLK Business Avenue Intelligence Solutions LLC
So here's what happened. I was in the Baddies of AI group helping ONE person, and I mentioned that you can host your own AI model. Not rent one. Not borrow one. Own one. Next thing I know I have 86 of you in my messages and notifications asking "wowww tell me how."
I don't have time to teach a live class, so I'm doing the next best thing: my exact step-by-step, written out in plain language, free, right here on MyBLKWorldHQ.
This is the same method I use. Claude Code in the terminal is required for this method. If anything in here sounds technical, keep reading — every term gets explained the first time it shows up. You do not need to be a coder. You need to be organized, patient, and willing to double-check everything.
Let's build.
How This Course Works
There are 5 modules and 24 steps. Do them in order. Each step tells you what to do, why you're doing it, and what "done" looks like.
Module 1: Set Up Your Accounts (Steps 1–5)
Module 2: Plan Your Model With Claude Chat (Steps 6–14)
Module 3: Connect Your Tools (Steps 15–19)
Module 4: Build and Verify (Steps 20–22)
Module 5: Make It Yours (Steps 23–24)
The Modal Walkthrough (11 parts — every click and command for your servers)
The Render Walkthrough (11 parts — every click for your website)
Then: The Real Cost of Owning Models (read this before you spend a dollar)
The main steps tell you WHEN to do something. The two walkthroughs, right after Step 24, tell you exactly HOW. When a step says "Modal Part 3," scroll to the Modal Walkthrough and do Part 3, then come back.
The Plain-Language Glossary (Read This First)
AI model: The "brain" that answers questions, writes, makes images, makes video, or makes audio. ChatGPT, Claude, and image generators all run on models.
Open-weight model: A model whose files (the "weights") are released publicly so anyone can download and run it on their own servers. This is what makes owning your own model possible. Not every open-weight model allows you to make money with it — that's what the license tells you.
License: The legal rules for the model. It tells you whether you can use it commercially (to make money), whether you need to give credit, and whether there are limits.
Hugging Face: The biggest library of AI models on the internet. Think of it as the "app store" where models live. Your model will be downloaded from here.
Modal: A cloud company that rents you powerful computers (servers with GPUs) by the second. Your model will RUN here. You only pay while it's actually working.
GPU: A special computer chip built for AI. Bigger models need bigger GPUs, or more of them.
Claude chat: The regular Claude app you talk to. In this course, Claude chat is your planner and researcher.
Claude Code: Claude's builder. It lives in your terminal and actually writes the code, installs things, and deploys your model.
Terminal: The text window on your computer where you type commands. On Mac it's called Terminal. On Windows it's called PowerShell. It looks intimidating. It's not. You'll mostly be pasting.
API key / token: A secret password that lets one service talk to another. Treat these like your bank PIN. Never post them, never screenshot them, never paste them in a group chat.
.md file (markdown): A simple text document with headings. You'll use one to hold the full instructions you give Claude Code.
.py file (Python): The code file Claude Code creates that tells Modal how to run your model.
Render: A hosting company that puts websites online. You only need it if you want a website for your model.
LoRA: A way to train your model on your own style, voice, or data without retraining the whole thing. Explained fully in Step 23.
What You Need Before You Start
A computer: Mac (macOS 13 or newer) or Windows (Windows 10 version 1809 or newer). A phone or tablet won't work for the terminal steps.
An internet connection.
A debit or credit card. Modal requires a payment method on file before it lets you use GPUs, even though you get free monthly credits.
An email address you check.
Patience. Re-verifying is part of the method, not a delay.
*MODULE 1: SET UP YOUR ACCOUNTS
Step 1: Download Claude and Subscribe
Go to claude.ai and download the Claude app for your computer (you can also use it in your browser).
You need a paid plan. The free plan does NOT include Claude Code, and Claude Code is the whole method.
Your options:
Pro — $20/month (or $17/month billed yearly). This is the minimum.
Max 5x — $100/month. Five times the usage of Pro. This is the plan I personally use.
Max 20x — $200/month. Twenty times the usage of Pro.
Why the bigger plan matters: Claude chat and Claude Code share the same usage. Building a model is a lot of back-and-forth, and on Pro you may hit your limit mid-build and have to wait for it to reset. If you're serious, Max is worth it.
Done looks like: You're logged into Claude on a paid plan.
Step 2: Complete Your Sign-Up
Finish everything Claude asks for during sign-up — email verification, payment, profile. If you already had a Claude account and upgraded it, skip this step.
Done looks like: No "finish setting up your account" banners anywhere.
Step 3: Create Your Modal Account
Go to modal.com and sign up.
What Modal is, in plain language: Modal rents you AI computers by the second. When someone uses your model, Modal turns on a GPU, runs the request, and turns it back off. When nobody's using it, you pay nothing for the GPU.
Do Modal Part 1 (create your account) and Modal Part 2 (add your payment method) in the Modal Walkthrough, then come back here.
Done looks like: You can log into your Modal dashboard, you can see your workspace name, and your card is on file.
*Step 4: Set Your Modal Spending Limit (Do Not Skip This)
This is the step nobody tells you about, and it's the one that protects your money.
Do Modal Part 3 (set your budget and spend limit) in the Modal Walkthrough. While you're in there, do Modal Part 4 (the dashboard tour) so you know where everything lives.
Why: AI coding agents can get stuck in a loop — trying the same failing build over and over — and every attempt runs on a GPU you're paying for. A low limit turns a disaster into a minor inconvenience. Start small, like $5–$20 while you're building, and raise it on purpose once everything works.
Done looks like: You can see your limit on the Usage & Billing page.
Step 5: Create Your Hugging Face Account
Go to huggingface.co and sign up. Confirm your email.
What Hugging Face is: the library your model will come from. Some models are "gated," meaning you have to click "agree" to the license on your own Hugging Face account before you're allowed to download them. Nobody can click that for you.
Done looks like: You're logged into Hugging Face and your email is confirmed.
MODULE 2: PLAN YOUR MODEL WITH CLAUDE CHAT
Step 6: Start Your Build Chat in Claude
Open Claude chat and start a fresh conversation just for this build. Keep everything about your model in this one chat so Claude has the full picture.
Tell Claude what you're doing. Copy and paste this:
"I'm building and deploying my own AI model using Claude Code in my terminal, Modal for the servers, and Hugging Face for the model files. At the end of this chat I'll need you to create a .md (markdown) artifact that contains the complete Claude Code build prompt. Everything we decide in this chat goes into that prompt. Use live web searches of official documentation for every fact."
Done looks like: Claude confirms the plan and you're ready to research.
Step 7: Get the License Chart
First decide what kind of model you want. Be exact:
LLM (a chat/text model — writes, answers, talks)
Image (makes or edits pictures)
Video (makes video)
Audio / voice (speech, voiceover, music)
All of the above
Then copy and paste this into Claude chat, filling in your type:
"Create an artifact: Give me a chart of the best open-weight models with commercial licenses for [YOUR MODEL TYPE]. List all license details in plain English — can I make money with it, do I need to give credit, are there user or revenue limits, is it gated on Hugging Face, who made it, and the exact Hugging Face repo name. Verified to industry standard. Perform live web searches of official docs including but not limited to Hugging Face, Modal, and each model's official platform information. Include the date you verified each entry."
Done looks like: You have a chart in an artifact, with sources.
*Step 8: Choose Your Model — Then Verify It Twice
Pick the model that fits what you want to build. Then verify the license yourself and ask Claude to cross-verify it:
Open the model's page on Hugging Face. Look at the "License" tag on the right side of the model card. Read it.
Ask Claude chat: "Re-verify the license for [MODEL REPO NAME] using a different official source than last time, and give me the most up-to-date information available. Tell me if anything changed."
What you're watching for: some licenses say "research only" or "non-commercial." Some allow commercial use but cap how many users you can have before you need a separate agreement. Some require you to show "Built with [name]." If you plan to sell anything — content, access, services — you need a license that clearly allows commercial use. When in doubt, choose a model with a simple, permissive license (Apache 2.0 and MIT are the cleanest).
Done looks like: You know your exact model, its exact Hugging Face repo name, and its license — confirmed twice.
Step 9: Accept the License on Hugging Face (If Your Model Is Gated)
If your model's Hugging Face page shows an agreement box or "Access request," fill it out and accept it while logged into YOUR account. Some are approved instantly; some take a review.
If your model isn't gated, skip this step.
Done looks like: The model page no longer asks you to agree — it shows the files.
Step 10: Get the Server Chart
Now figure out what computers your model needs. First, answer one question honestly:
Is this model just for YOU, or for you AND others (customers, members, a community)?
That answer decides your scale. One person sending a few requests needs far less than a hundred people at once. More users at the same time means more servers (more GPUs) or bigger ones.
Copy and paste this into Claude chat:
"Create an artifact: Give me a chart of the Modal GPU server options that fit [MODEL REPO NAME]. This model is for [just me / me and others — about how many people at once]. For each option, tell me the GPU type, the exact number of GPUs needed, whether the model fits in memory, the current Modal price per second and per hour, and what speed to expect. Verify against Modal's official pricing and GPU documentation and the model's official Hugging Face page with live web searches. Tell me the exact number of servers I need — I'm giving this number to Claude Code for the .py file."
Plain-language tip: GPU "memory" (VRAM) is the big one. If the model doesn't fit in the GPU's memory, it won't run. Bigger models need bigger GPUs or several GPUs working together. Fewer GPUs is easier to get and simpler to run — if a one-GPU option fits, it's usually the smart choice.
Done looks like: You know the exact GPU type and exact number of GPUs.
Step 11: Choose Your Servers — Then Verify Modal Pricing
Pick your server option. Then re-verify and cross-verify the price with Modal's official pricing page (modal.com/pricing) and ask Claude to check it again.
For reference, here are Modal's posted GPU rates as of October 2026 (always check the live page — prices change):
Nvidia T4 — about $0.59/hour
Nvidia L4 — about $0.80/hour
Nvidia A10 — about $1.10/hour
Nvidia L40S — about $1.95/hour
Nvidia A100 40GB — about $2.10/hour
Nvidia A100 80GB — about $2.50/hour
Nvidia H100 — about $3.95/hour
Nvidia H200 — about $4.54/hour
Nvidia B200 — about $6.25/hour
Modal bills by the second, and you're not charged for idle time once your model scales down. Multiply by the number of GPUs: 2 GPUs = double the rate.
Done looks like: You have a confirmed GPU type, GPU count, and current price.
Step 12: Decide — Model Only, or Model + Website?
Before you write the prompt, decide how people will use your model:
Model only: You (or your apps) talk to it directly. Simplest. No website needed.
Model + website for you: A private site where you log in and use your model.
Model + website for others: A public site where customers or members use it.
If you want a website, you'll also need a GitHub account (free, at github.com — it stores your website's code) and a Render account (Step 19). This decision goes INTO your Claude Code prompt, so make it now.
Done looks like: You've chosen one of the three paths.
Step 13: Have Claude Chat Build Your Claude Code Prompt (.md Artifact)
Now Claude chat turns everything you decided into one set of instructions for Claude Code.
Copy and paste this into the same Claude chat:
"Create a .md (markdown) artifact containing the complete Claude Code build prompt for my model. Include: the exact Hugging Face repo name and license; the exact Modal GPU type and number of GPUs; that my Hugging Face token is stored as a Modal secret; that the model must scale to zero when idle so I don't pay for idle time; that the model's endpoint must be protected so strangers can't use it and run up my bill; my website decision [model only / website for me / website for others] and that Render is the host if there's a website; that Claude Code must perform live web searches of official Modal, Hugging Face, and model documentation before building each part and build to industry standard; that Claude Code must stop and ask me after 3 failed attempts at anything instead of retrying; and that Claude Code must report to me after each phase. Write it so I can copy and paste it straight into Claude Code."
Download or copy the artifact when it's done.
Done looks like: You have one .md prompt saved on your computer.
*Step 14: Re-Verify Your Prompt
Read the whole prompt yourself. Then ask Claude chat to check it:
"Re-verify this Claude Code prompt against current official Modal and Hugging Face documentation with live web searches. Confirm it requires industry-standard build quality, scale-to-zero, a protected endpoint, a 3-attempt stop rule, and the exact GPU count. Fix anything outdated and give me the corrected .md."
Your own checklist — the prompt must say:
The exact model repo name (not "a Llama model" — the exact name)
The exact GPU type and number
Scale to zero when idle
Protect the endpoint
Live web searches of official docs before building
Industry-standard build quality
Stop and ask after 3 failed attempts
Your website decision
Done looks like: Every box is checked.
MODULE 3: CONNECT YOUR TOOLS
Step 15: Install Claude Code in Your Terminal
Open your terminal:
Mac: press Command + Space, type Terminal, press Enter.
Windows: click Start, type PowerShell, press Enter.
Paste the install command for your computer and press Enter.
Mac:
curl -fsSL https://claude.ai/install.sh | bash
Windows (PowerShell):
irm https://claude.ai/install.ps1 | iex
The installer doesn't show progress while it downloads, so give it a moment. When it finishes, close the terminal, open a NEW one, and type:
claude --version
If you see a version number, you're in. If it says "claude" isn't recognized, follow the "Fix your PATH" help on Claude Code's official setup page.
Windows tip: installing Git for Windows (git-scm.com) is optional but recommended — it gives Claude Code more tools to work with.
Done looks like: claude --version prints a number.
Step 16: Log In to Claude Code
In your terminal, type:
claude
Claude Code opens and walks you through logging in through your browser. Choose to log in with your Claude subscription (the Pro or Max plan you bought in Step 1). Once you approve it in the browser, you're connected.
Done looks like: Claude Code is open in your terminal and ready for a message.
Step 17: Connect Modal to Your Computer
Do Modal Part 5 (install Modal and connect your computer) in the Modal Walkthrough.
Done looks like: modal app list runs without an error.
Step 18: Connect Hugging Face to Modal
Your model needs permission to download from Hugging Face. Here's how:
1. On huggingface.co, click your profile picture, then Settings, then Access Tokens.
2. Click New token. Name it something like "modal-my-model." Choose Read access (or a fine-grained token with read access to just your model — that's the safest option Hugging Face recommends for real projects).
3. Copy the token. It starts with hf_.
4. Do Modal Part 6 (store your Hugging Face token as a Modal secret).
5. Do Modal Part 7 (create your proxy auth token — the lock on your model's front door).
Never paste these tokens into a chat with other people, a screenshot, or your website code. If one ever leaks, delete it and make a new one.
Done looks like: Modal's Secrets page shows your Hugging Face secret, and your proxy token ID and secret are saved in your password manager.
Step 19: Connect Render (Website Path Only)
Skip this step if you chose "model only" in Step 12.
What Render is: the company that puts your website on the internet. (Costs are broken down in The Real Cost of Owning Models.)
Do these parts of the Render Walkthrough now, before you build:
Render Part 1 (GitHub account)
Render Part 2 (Render account)
Render Part 3 (connect GitHub to Render)
Render Part 4 (connect Render to Claude Code)
The rest of the Render Walkthrough happens in Step 22, after Claude Code builds your website.
Done looks like: Inside Claude Code, type /mcp and Render shows as connected.
MODULE 4: BUILD AND VERIFY
Step 20: Give Claude Code Your Prompt
1. Make a new folder on your computer for this project (example: my-ai-model).
2. Open your terminal IN that folder. (Mac: type cd and a space, drag the folder into the terminal, press Enter. Windows: in File Explorer, open the folder, click the address bar, type powershell, press Enter.)
3. Type claude to start Claude Code.
4. Paste your entire .md prompt from Step 14 and press Enter.
Claude Code will ask permission before it runs commands. READ what it's asking. You're the owner — you approve the moves. Don't switch it to fully automatic until your spending limit from Step 4 is set and you trust what it's doing.
Claude Code will create your .py file, deploy your model to Modal (Modal Part 8 explains what it's doing and what to look for), and, if you chose it, build your website and push its code to your private GitHub repository.
Done looks like: Claude Code reports that your model is deployed and gives you an endpoint (a web address where your model answers).
Step 21: Verify Your Modal Build
Don't take anyone's word for it — including Claude Code's. Do Modal Part 9 (verify your deployment) yourself, and read Modal Part 10 (stopping and redeploying) so you know how to shut it off if you ever need to.
Heads up on "cold starts": when your model has been asleep, the first request takes longer because Modal has to wake up a GPU and load the model. That's normal, and it's the trade-off for not paying for idle time.
Done looks like: Deployed, tested, answered, and back to zero.
Step 22: Verify Your Website (Website Path Only)
Now put your website online. Do Render Parts 5 through 11 in the Render Walkthrough:
Render Part 5 (create your web service)
Render Part 6 (add your environment variables)
Render Part 7 (deploy and go live)
Render Part 8 (auto-deploys)
Render Part 9 (add a database, only if your site has logins or saves history)
Render Part 10 (connect your own domain)
Render Part 11 (logs and fixing problems)
Done looks like: Your site is live on its own address and your model answers through it.
MODULE 5: MAKE IT YOURS
Step 23: Train It Further With a LoRA
Right now you're running someone else's base model on your own servers. A LoRA is how you make it truly yours.
What a LoRA is, plainly: Instead of retraining the entire model (extremely expensive), a LoRA trains a small "add-on" layer that sits on top of the model and teaches it something specific — your writing voice, your brand style, your product knowledge, a specific art style, your face for image models. It's like giving the model a specialty without rebuilding its brain. LoRAs are small, faster to train, and can be swapped in and out.
Ask Claude chat:
"Explain how to train a LoRA for [MODEL REPO NAME] on Modal using live web searches of official Modal and Hugging Face documentation. Tell me what training data I need, how much, what format, which GPU and how long the training job would run on it, what it will cost on current Modal pricing, and whether the model's license allows fine-tuning for commercial use. Then build me a Claude Code prompt for it as a .md artifact."
Only train on data you own or have the rights to use.
Done looks like: You have a LoRA plan and a prompt ready when you are.
Step 24: NAME IT!
You're not a user anymore. You're the OWNER of your own AI model.
Give it a name that's yours. Not the base model's name — YOUR name. That's your brand, your product, your asset. Ask Claude Code to update the app name in your Modal deployment and anywhere it shows on your website.
Welcome to ownership, Baddie.
THE MODAL WALKTHROUGH
Modal is where your model lives and runs. These 11 parts cover every click and command, from opening your account to shutting your model off. Modal updates its dashboard from time to time, so if a button name is slightly different, look for the closest match in the same area.
Modal Part 1: Create Your Account
1. Go to modal.com and click Sign up.
2. Choose one of the sign-up options on the page and finish the steps it asks for.
3. Modal creates your workspace. Your workspace is your private corner of Modal. Its name shows up in the dashboard and inside your model's web address later, so write it down exactly as shown.
Done looks like: You're looking at your Modal dashboard.
*Modal Part 2: Add Your Payment Method
1. In the dashboard, open Settings.
2. Go to the billing area (Usage & Billing, or Plans).
3. Stay on the Starter plan. It's $0 per month plus what you use, and it includes $30 in free credits every month.
4. Add your debit or credit card. Modal requires a card on file before it lets you use GPUs, even when your free credits cover the cost.
Done looks like: Your plan says Starter and your card is saved.
Modal Part 3: Set Your Budget and Spend Limit
This is your safety net. Do it before anything touches a GPU.
1. Go to Settings, then Usage & Billing (direct link: modal.com/settings/usage).
2. Find the workspace budget, also shown as your usage limit. This caps your total usage for the month, counted before your free credits.
3. Set it low while you're building. $5 to $20 is plenty for setup and testing.
4. Find the spend limit. This caps what you pay out of pocket after your free credits are used up. If you don't set one, Modal uses your usage limit minus your credits.
5. Save.
What happens at the limit: Modal stops any work that would charge you more. Your model goes quiet instead of your bank account going empty. When everything works and you're ready for real users, come back and raise it on purpose.
Done looks like: Your limit shows on the Usage & Billing page.
Modal Part 4: The Dashboard Tour
Know where everything lives before you need it in a hurry:
Apps: Every model you deploy shows up here. Click one to see its status, its logs (the running record of what it's doing and any errors), its Deployment History, and the red Stop app button.
Secrets: Your locked passwords, like your Hugging Face token. Your code can use them, but they never show up in your code.
Storage (Volumes): Where your model's files are saved so they don't download from scratch every time it wakes up.
Settings: Billing, your usage limit, your proxy auth tokens (Part 7), and your workspace details.
Done looks like: You can find Apps, Secrets, and Usage & Billing without searching.
Modal Part 5: Install Modal and Connect Your Computer
Your computer needs Modal's tool so Claude Code can deploy to your account.
1. Install Python if you don't have it. Download the current version from python.org. On Windows, check the box that says "Add python.exe to PATH" on the first install screen. (You can also ask Claude Code to check for Python and install it for you.)
2. Open your terminal and run:
pip install modal
3. Then run:
modal setup
If that doesn't work, run this instead:
python -m modal setup
4. Your browser opens. Log into Modal and approve the connection.
5. Back in your terminal, you'll see that your token was verified. That token is now saved on your computer, so Claude Code can deploy to YOUR workspace.
6. Test the connection:
modal app list
If it shows an empty list or a list of apps without an error, you're connected.
Done looks like: modal app list runs without an error.
Modal Part 6: Store Your Hugging Face Token as a Secret
You made your Hugging Face token in Step 18. Now lock it inside Modal.
1. In the Modal dashboard, click Secrets.
2. Click Create new secret.
3. Choose the Hugging Face template from the list.
4. Paste your token (it starts with hf_) as the value for HF_TOKEN.
5. Name the secret huggingface-secret (or any simple name), and write the name down. Your Claude Code prompt must use this exact name.
6. Click Create.
Use the dashboard instead of typing the token into your terminal. Tokens typed into the terminal can stay in your command history.
Done looks like: huggingface-secret is listed on your Secrets page.
Modal Part 7: Create Your Proxy Auth Token (Lock Your Front Door)
Your model gets a web address. Without a lock, anyone who finds that address can use your model, and you pay for every request. A proxy auth token is the lock.
1. Go to Settings, then Proxy Tokens (direct link: modal.com/settings/proxy-auth-tokens).
2. Create a new token.
3. You'll get two pieces: a Token ID and a Token Secret. Copy both into your password manager right away.
4. Tell Claude Code your model's endpoint must require proxy auth. In the code, that's requires_proxy_auth=True. Without it, Modal's basic web functions are open to the public.
5. Anything that talks to your model, like your website, sends both pieces with every request: Modal-Key (your Token ID) and Modal-Secret (your Token Secret). Requests without them get turned away.
Never put these in your website's code. They go into Render as environment variables (Render Part 6).
Done looks like: Your Token ID and Token Secret are saved in your password manager.
Modal Part 8: Deploying (What Claude Code Is Doing)
When Claude Code deploys, it runs a command like this:
modal deploy your_model_file.py
Know the difference between the two commands you'll see:
modal run: a test run. It runs once and goes away.
modal deploy: the real thing. Your model stays live with a permanent web address, even when your laptop is closed.
After a deploy, the terminal shows your model's web address. It looks like this:
https://yourworkspace--your-app-name.modal.run
Save it. Your website (or anything else using your model) needs it. You can also find it later in the dashboard: Apps, then your app.
Every time you deploy again, Modal updates your app and adds a new version to its Deployment History.
Done looks like: You have your modal.run web address saved.
Modal Part 9: Verify Your Deployment
1. In the dashboard, click Apps. Your app should show as deployed.
2. Click your app. Look at its Overview and its logs. Red text means errors. Copy any error into Claude Code and ask it to explain and fix it. (Remember your 3-attempt rule.)
3. Ask Claude Code for the exact command to send one test request to your model, including your proxy token. Run it once and confirm an answer comes back.
4. Run the same test WITHOUT the proxy token. It should be refused. That proves your lock works.
5. Leave the model alone for a few minutes. On the app's page, watch the number of running containers drop back to zero. That's scale-to-zero working.
6. Go to Usage & Billing and see what your test cost.
Done looks like: Deployed, answered with the token, refused without it, and back to zero.
Modal Part 10: Stopping and Redeploying
To see everything you have running, use:
modal app list
To shut a model off completely, use either option:
In your terminal: modal app stop your-app-name
In the dashboard: Apps, then your app, then the red Stop app button.
Know this before you click: stopping is permanent for that deployment. It can't be "un-stopped." To bring your model back, deploy it again from the same file:
modal deploy your_model_file.py
Keep your .py file safe. It's your model's blueprint.
If you only want to stop paying while nobody's using it, you don't need to stop anything. Scale-to-zero already does that.
Done looks like: You know how to list, stop, and bring back your model.
Modal Part 11: Check Your Bill Weekly
Make Usage & Billing a weekly habit:
1. Look at what you've used so far this month and how much of your $30 credit is left.
2. If something costs more than you expected, open Apps, find the app, and check its logs and container count for something that's stayed on.
3. Raise your limit (Part 3) only when you mean to.
Done looks like: No surprises on your statement. Ever.
THE RENDER WALKTHROUGH
Render puts your website on the internet. Your model stays on Modal. Render runs the pages people see, their logins, and the connection that sends their requests to your model. Skip this walkthrough if you chose "model only" in Step 12. Render also updates its dashboard from time to time, so look for the closest match if a button name has changed.
Render Part 1: Create Your GitHub Account
GitHub stores your website's code, and Render builds your site from it.
1. Go to github.com and sign up for a free account.
2. Verify your email.
3. When Claude Code builds your website (Step 20), tell it to put the code in a PRIVATE GitHub repository. A repository ("repo") is a folder for one project's code. Private means only you can see it.
Done looks like: You're logged into GitHub.
Render Part 2: Create Your Render Account
1. Go to render.com and click Get Started.
2. Sign up. Signing up with GitHub saves you a step later.
3. Choose the Hobby workspace plan: $0 per month plus whatever your services use. It's made for personal projects and gives you 1 seat, up to 25 services, and 5 GB of bandwidth.
4. If you add a card, Render charges $1 to check it and then refunds it. That's normal.
Done looks like: You're looking at your Render dashboard.
Render Part 3: Connect GitHub to Render
1. In the Render dashboard, click New, then Web Service.
2. Choose Git Provider as the source.
3. Connect your GitHub account and approve access when GitHub asks. You can give Render access to all your repos or just the ones you pick. Picking only your website's repo is the safer choice.
4. You can back out of the form now. You'll come back once your website code exists (Part 5).
Done looks like: Render can see your GitHub account.
Render Part 4: Connect Render to Claude Code
This lets Claude Code read your Render services, logs, and settings directly instead of guessing.
1. In Render, go to Account Settings, then API Keys.
2. Create a new API key and copy it. Treat it like a password.
3. In your terminal, run this with your key in place of YOUR_API_KEY:
claude mcp add --transport http render https://mcp.render.com/mcp --header "Authorization: Bearer YOUR_API_KEY"
4. Restart Claude Code.
5. Inside Claude Code, type /mcp. Render should show as connected.
Render also supports signing in through your browser for Claude Code. Check render.com/docs/mcp-server for the current steps if you'd rather do it that way.
Done looks like: /mcp shows Render as connected.
Render Part 5: Create Your Web Service
Do this after Claude Code has built your website and pushed it to your private GitHub repo. (Claude Code can also do this part for you through the Render connection. These are the manual steps, so you know what's happening either way.)
1. In the Render dashboard, click New, then Web Service.
2. Choose Git Provider, then pick your website's repo.
3. Fill in the form:
Name: your site's name. It becomes your free web address: yourname.onrender.com.
Region: choose the one closest to most of your users.
Branch: usually main. Ask Claude Code which branch it used.
Language: the language your site is built in. Ask Claude Code.
Build Command: the command that prepares your site. Claude Code gives you the exact one.
Start Command: the command that turns your site on. Claude Code gives you the exact one.
4. Choose your compute plan:
Free: $0, but it sleeps when nobody visits and takes a moment to wake up.
Starter: $7 per month, always on.
Standard: $25 per month, for real traffic.
5. Don't click create yet. Do Part 6 first.
One technical must-have: your site has to listen on host 0.0.0.0 and on the port in Render's PORT setting (the default is 10000). If it doesn't, the deploy fails. Make sure Claude Code built it that way.
Done looks like: The form is filled in and your plan is chosen.
Render Part 6: Add Your Environment Variables
Environment variables are your site's private settings, like the web address of your model and the keys to its lock. They live in Render, never in your code.
1. On the same form, open Advanced.
2. Add each variable Claude Code tells you your site needs. For this build, that usually means:
Your model's modal.run web address (from Modal Part 8)
Your proxy Token ID (from Modal Part 7)
Your proxy Token Secret (from Modal Part 7)
Use the exact variable names Claude Code used in your site's code.
3. Double-check for extra spaces before or after each value. One stray space breaks the connection.
To change these later, open your service in the dashboard and go to its Environment page.
Done looks like: Every variable your site needs is filled in.
Render Part 7: Deploy and Go Live
1. Click Create Web Service.
2. Render starts building. Watch the progress on your service's Deploys page.
3. When the status says Live, click your onrender.com address at the top of the page.
4. Use your model through your site. Send a real request and confirm you get an answer.
Render handles your security certificate automatically, so your site opens on https.
Done looks like: Your site is Live and your model answers through it.
Render Part 8: Auto-Deploys
Because your site is connected to GitHub, every time Claude Code pushes a change to your branch, Render rebuilds and redeploys your site automatically. You don't click anything.
To update your site: ask Claude Code for the change, have it push to GitHub, then watch the Deploys page until the new version says Live.
Done looks like: You know every push means a new version.
Render Part 9: Add a Database (Only If You Need One)
You need a database if your site has user accounts, logins, or saves anyone's history. You don't need one for a simple private site.
1. In the dashboard, click New, then Postgres.
2. Name it and pick the SAME region as your web service so they can talk privately.
3. Choose a plan. Free has limits. Paid starts at $6 per month.
4. Click create. Render gives you a connection address for the database.
5. Add that connection address to your web service as an environment variable (Part 6). Ask Claude Code which variable name your code expects.
Or ask Claude Code to create the database for you through the Render connection.
Done looks like: Your database shows as available and your site connects to it.
Render Part 10: Connect Your Own Domain
Your free onrender.com address works fine. When you want your own name, like yourbrand.com:
1. Buy the domain from any domain company if you don't own one yet.
2. In Render, open your web service, then Settings, then scroll to Custom Domains.
3. Click + Add Custom Domain, type your domain, and click Save. It shows as needing a DNS update. (If you add the www version, Render adds the plain version too, and one redirects to the other.)
4. Go to the company where you bought your domain and open its DNS settings. Delete any AAAA records for the domain. Then add the records Render shows you. Render has step-by-step guides for Cloudflare, Namecheap, and other providers in its custom domains docs.
5. Back in Render, click Verify next to your domain. If it fails, wait a few minutes and try again. DNS changes take time to spread.
6. Once verified, Render issues your security certificate automatically. If you see a 502 error right after, wait a few minutes.
Done looks like: Your site opens at your own domain with https.
Render Part 11: Logs and Fixing Problems
1. Open your web service and click Logs to see what your site is doing in real time. Errors show up here first.
2. If a deploy fails, open the Deploys page, click the failed deploy, and read the build log.
3. The three most common problems:
Wrong port: the site isn't listening on 0.0.0.0 and the PORT setting (Part 5).
Missing or mistyped environment variable: check every name and value (Part 6).
Wrong build or start command: confirm them with Claude Code (Part 5).
4. Easiest fix: ask Claude Code, "Read my Render logs and tell me why my deploy failed." Through the Render connection, it can read them directly. Your 3-attempt rule still applies.
Done looks like: You know where to look and who to ask when something breaks.
THE REAL COST OF OWNING MODELS
I promised you the truth, so here it is. Owning your model is powerful — and it comes with real costs. Know them before you start.
Your Fixed Costs
Claude: $20/month minimum (Pro), $100 or $200/month for Max. This is your builder.
Hugging Face: A free account works for this method.
Everything else depends on how much your model gets used. That's Modal and Render, broken down below.
*How Modal Charges You (Plain Language)
Modal charges by the second for three things while your model is ON: the GPU (the big cost), the CPU, and memory (both tiny next to the GPU).
Your model is "ON" from the moment it wakes up until it goes back to sleep. That includes:
Waking up (the cold start, while the model loads)
Answering requests
The warm-down window, a short wait after the last request before it sleeps, in case another request comes in. Claude Code sets this in your .py file. Longer window = fewer cold starts but more billed time.
When it's asleep, you pay $0 for the GPU.
Storage is separate: your model's files sit in Modal storage so they don't re-download every time. Modal's posted storage rate is $0.09 per GB per month. Big models are big files, so check the live pricing page for what your plan includes.
Starter plan: $0/month plus usage, $30 in free credits every month, and up to 10 GPUs running at once.
Team plan: $250/month plus usage, $100 in free credits, and up to 50 GPUs at once. You only need this if you outgrow 10 GPUs.
The one formula you need:
GPU price per hour × number of GPUs × hours your model is ON per month = your monthly GPU cost. Then subtract your $30 credit.
Scenario 1: Just You (Individual Use)
Your model sleeps most of the day and wakes up when you use it.
Light use, about 30 minutes ON per day (around 15 hours a month):
1 L40S GPU ($1.95/hr): about $29/month. Your $30 credit covers it.
1 H100 GPU ($3.95/hr): about $59/month. About $29 after credits.
Daily use, about 2 hours ON per day (around 60 hours a month):
1 L40S GPU: about $117/month. About $87 after credits.
1 H100 GPU: about $237/month. About $207 after credits.
The lesson: for personal use, a smaller GPU that fits your model plus scale-to-zero keeps you at pocket change.
Scenario 2: You + Your Community (Small Platform)
Now other people are using it, so it wakes up more and stays on longer. Many platforms keep the model ON during their busy hours so customers don't wait through cold starts.
ON 8 hours a day, every day (around 240 hours a month):
1 L40S GPU: about $468/month.
1 H100 GPU: about $948/month.
One GPU can usually handle several people's requests at the same time. How many depends on your model and your setup, so ask Claude chat to estimate it for YOUR model before you launch.
Scenario 3: Mass-User Platform
Lots of users, at all hours. Now your model stays ON around the clock, and at busy times Modal adds more GPUs automatically (that's called autoscaling).
1 H100 ON 24/7: about $2,843/month.
1 H100 ON 24/7, plus 3 more H100s added for 8 busy hours a day: about $5,687/month.
Need more than 10 GPUs at once? That's the Team plan, adding $250/month.
At this level you must price your platform from your costs. Example: $2,843 a month ÷ 200 paying users = about $14.22 per user just to break even on the GPU. Charge less than that and every new user costs you money. That's why platforms charge per use or per credit instead of one flat price for unlimited use.
How Render Charges You (Website Path Only)
Render does NOT run your AI model. Modal does that. Render runs your website: the pages people see, their logins, their accounts, and the part that sends their requests to your model on Modal.
Render charges for four things:
1. Your workspace plan:
Hobby: $0/month. 1 seat, up to 25 services, 5 GB of bandwidth included. Made for personal projects.
Pro: $25/month. Unlimited seats and services, 25 GB of bandwidth included. Made for production apps.
2. Your website's server (Render calls it a "web service"), billed by size:
Free: $0, but it goes to sleep when nobody visits and takes a moment to wake up.
Starter: $7/month (512 MB memory). Always on.
Standard: $25/month (1 CPU, 2 GB memory). For real traffic.
Bigger sizes go up from there ($85/month and up).
A static site (a site with no logins or databases) is free to host.
3. Your database (only if you store users, accounts, or history):
Free: $0, with limits.
Smallest paid: $6/month. Next sizes up: $19/month, then $40/month.
4. Extras:
Bandwidth past your included amount: $0.15 per GB.
Build minutes (each time your site redeploys): 500 included on Hobby, then $5 per 1,000 minutes.
Custom domains: 2 included on Hobby (15 on Pro), then $0.25 per domain per month.
Render by Scenario
Just you, private site: Hobby ($0) + free web service ($0) = $0, if you don't mind it sleeping. Or Hobby + Starter ($7) = $7/month, always on.
Small community platform: Hobby ($0) + Starter web service ($7) + smallest paid database ($6) = about $13/month.
Mass-user platform: Pro ($25) + Standard web service ($25) + $19 database = about $69/month, plus bandwidth as you grow.
Your Total Monthly Picture
Add it up: Claude + Modal + Render (if you have a website) + storage.
Just you: $20–$100 Claude + $0–$207 Modal + $0–$7 Render.
Small community platform: $100 Claude + $468–$948 Modal + about $13 Render.
Mass-user platform: $100–$200 Claude + $2,843 to $5,687 or more Modal + about $69 or more Render.
All prices are from Modal's and Render's official pricing pages as of October 2026. Prices change, so always re-verify before you build.
What Nobody Puts in the Tutorial
Test runs cost money. Every time Claude Code tests a deploy, a GPU turns on.
Loops cost money. If a build keeps failing and keeps retrying, every retry is billed. That's why the 3-attempt stop rule is in your prompt.
Things left running cost money. One forgotten test can eat your whole limit.
Your time costs money. Debugging, re-verifying, waiting on GPUs that aren't available, re-reading license fine print — this is real work.
Maintenance is forever. Models update. Libraries update. Licenses change. Somebody has to keep it all current. If you own it, that somebody is you.
None of this should scare you off. It should make you strategic. Some of you want to own the whole engine. Some of you want the result without the overhead. Both are smart. So here are your other options.
Option 1: Use BLK-AI
If what you really want is powerful AI — without managing servers, GPUs, licenses, and loops — BLK-AI is already built, already self-hosted, and already sovereign.
BLK-AI is available at discounted rates for specific users, and new members get 25 BLKCOIN ($25) in free credits to start. BLKCOIN is pegged 1:1 to the dollar — 1 BLKCOIN = $1. No cold servers to babysit. No surprise GPU bills. Just create.
Start here: https://myblkworldhq.com/blk-ai
Option 2: Build Your Own Model AND Platform With BLKBUILDER
If you want to OWN your model but want the most streamlined path there, this is it. BLKBUILDER has a build made for exactly this.
Here's how it works: a straightforward intake, you connect your own Modal and Hugging Face accounts, you choose your model, and BLKBUILDER builds it — plus a platform to go with it, hosted directly on myblkworldhq.com, with sections for whatever your model does (chat, images, video, audio, e-books, and more).
BLKBUILDER completes the build to ADA accessibility, Modal, and Hugging Face compliance, bundled with hosting. Every model in the menu shows its license, company, and whether it allows commercial use — so you're not guessing. It's the most straightforward way to build your own model.
Instant build: $399. (Signup for free, click BLK-AI: Chat within the menu, choose live chat, message us "BLK BADDIES CUSTOM MODEL" and we will send you a link to create your model utilizing BKBUILDER for only $129!)
Start here: https://myblkworldhq.com/blkbuilder
Your Move
DIY with this course. Create with BLK-AI. Or own it all the easy way with BLKBUILDER. Whichever path you choose — choose ownership.
Building like a Baddie isn't about doing everything the hard way. It's about knowing exactly how it works, so nobody can ever tell you it's out of reach.
Ya'mia Oshun
CEO, BLK Business Avenue Intelligence Solutions LLC
THE NEW ERA OF DIGITAL LUXURY. We Are The Kingdom. Asè.