How to build an AI language tutor for your business with Lovable (no coding required)
Build a working language tutor in a browser tab, message by message. Chat practice that corrects as it goes, flashcards and exercises made for the level, a dictionary in the lesson, daily streaks, and a ceiling per learner on what your own AI key can spend, with Lovable designing the tables and the access rules in the same chat that builds the dashboard.
Lovable
$ Build a language learning app: learners pick a language, chat with a tutor that replies in it and corrects their mistakes, drill flashcards and fill-in-the-blank exercises made for their level, look up words and translate phrases, and keep a daily streak. Keep each learner’s progress to themselves.
- Tutor answering in the preview
- Drills and streaks built
- Ready to preview
Overview & core architecture
An AI language tutor is a practice partner rather than a course: a learner types in the language they are learning, gets a reply in it with their mistakes corrected, and drills what came up, with the model answering on your own key rather than a subscription per learner.
The usual version of this is a course app. Somebody wrote the lessons, recorded the audio, and charges every learner the same amount a month for the same path through them, whether they open the app every day or twice. Every product in the comparison further down works that way.
This version replaces the fixed path with a conversation. The learner says what they can, the tutor replies in the target language and points out what to fix, and the flashcards and exercises are generated around that level rather than pulled from a fixed deck. Behind it sit a dictionary and translator for the moment a word is missing, and a streak per activity that brings people back tomorrow.
What changes underneath is the bill. Every reply, card and exercise is one call to your AI provider at a per-token price, so a learner who practises for an hour a day costs you cents and a learner who never opens the app costs you nothing. The honest consequence, and the first decision below, is that a tutor on your own key needs a ceiling per learner, because the template ships without one.
The correction is the product
A chatbot that answers in Spanish is a novelty. A tutor that answers in Spanish, shows the learner the two words they got wrong and carries on the conversation is a lesson, and the prompt that makes the model do the second thing rather than the first is the most valuable text in this build.
Content is generated, not authored
No course to write and no audio to record. Cards and exercises come from the model for the language and the level the learner chose, which is why six languages ship on day one and a seventh is a line in a list, with the caveat that generated content needs a check a curated course does not.
The seat is the meter you remove
A course app charges per learner per month. A tutor on your own key charges per message, and the two diverge in your favour exactly where a subscription is most profitable: the learners who signed up and rarely practise.
Essential language tutor components
Six building blocks make up the tutor, and the corrected conversation is the one to prove first. Each is something you can ask your AI coding tool to build or rework in plain words.
Chat practice with corrections
The learner writes in the language they are learning and the tutor replies in it, marks what was wrong and why in a line or two, and keeps the conversation going. The last several turns travel with each message so the tutor remembers what was said, and the reply is rendered as formatted text rather than a wall of words.
Flashcards made for the level
Vocabulary cards generated for the chosen language and difficulty, flipped to reveal the meaning, with a speaker button that reads the word aloud using the visitor’s own browser voices.
Fill-in-the-blank exercises
Sentences generated at a chosen difficulty with a word missing, checked as the learner types, so practice follows what the conversation just surfaced rather than a fixed deck.
Dictionary & translator
The meaning of a word in the target language, and a phrase translated in either direction with one tap to swap the languages, without leaving the lesson to look it up somewhere else.
Per-activity daily streaks
A streak for chat, for cards, for exercises and for the dictionary, each recorded when the learner completes something, shown as counters on the dashboard and as a week view with charts on its own page.
Learner accounts & settings
Sign-up and sign-in, a profile per learner with their native and target languages, settings and a password change, and a demo mode that shows the dashboard to a visitor without an account.
Own the tutor or rent a seat in a course
Every product below charges per learner per month, packaged four different ways: monthly, prepaid for a year, prepaid for longer, or once for life. None of them charges for what a learner actually did. A tutor on your own key does, which is the number to hold on to while you read the table.
Build your own
Own the tutor outright: the learners, their progress and their streaks sit in a database you control, the content is generated for the languages and levels you choose, and the only bill that moves is the model calls you route through your own AI key. With an AI coding tool writing the machinery, that build is weeks rather than a quarter.
- No seat to buy, so a learner who signs up and rarely practises costs nothing
- Model calls at the provider’s per-token price on your own key, with a ceiling you set per learner
- Your own branding, your own sign-in and your own learners, which none of the four allows
- Languages, levels and the tutor’s manner are yours to decide rather than a catalogue to pick from
- Progress and streaks live in your database, so reporting and export are yours to define
- The code and the records are yours outright, and can move to any host you like
Rent a course
Rosetta Stone · Mango Languages · Ling · DropsRenting buys a curriculum written by people, audio recorded by native speakers, and a company that keeps both current across dozens of languages. What it costs is a price per learner per month, paid whether or not they practise.
- Lessons designed by people and recorded by native speakers, which a generated card is not
- Dozens of languages on day one, against the handful you configure
- Live this afternoon, with somebody else absorbing the model and content changes
- A price per learner per month on all four, however little that learner practised
- A curriculum rather than a conversation, so a learner who wants to talk is still on rails
- No corrections of what the learner actually wrote, because nothing in a fixed course reads it
The plainest version of the seat: one learner, one price a month, the same whether they finish a unit a day or none. The annual plan is a third cheaper for a year paid up front, which is the usual shape of the discount on every row here. Rosetta Stone is the row to read for what a curated course with speech practice built in costs, because that is what a generated tutor is not.
rosettastone.com · checked September 2026
The row that prices a household rather than a person: five profiles for one price, which is the closest any of these comes to the shape of a tutor you run for a group. The catalogue is the argument, seventy languages against the six this template ships with, and the counter-argument is that all seventy follow the same fixed path.
mangolanguages.com · checked September 2026
Priced by how long you commit: the monthly rate almost halves once a learner pays for a year up front, which tells you where the margin is. A free tier with limited lessons and ads is what most learners meet first, and the paid tier removes the limit rather than adding a different kind of practice.
ling-app.com · checked September 2026
The row with a lifetime price, which is the packaging closest to owning something and still not the same thing: a lifetime licence to somebody else’s vocabulary games, with no learners of your own on it. Worth reading against the one-time cost of a build, because it is the only row where the comparison is one price to one price.
languagedrops.com · checked September 2026
Rule of thumb: if you want to learn a language yourself, do not build this. Any row above teaches you more for less than the weeks below cost, and a curriculum written by people beats a generated deck for a beginner. If you teach, run a school, train staff or want a product of your own, the seat is the bill, and a tutor on your own key turns a price per learner into cents per lesson. The honest middle case is a tutor for beginners in a language you do not speak yourself, and there the right answer is to build it and have a native speaker check what the model generates before learners see it.
Why build with Lovable
Skip the curriculum and the server engineering. Describe the tutor, the drills and the streaks you want, say who may sign in, and every learner’s progress is saved under their own account without you writing server code.
Lovable turns that work into a conversation: describe a screen or a rule in plain language and watch it appear in the live preview, in the same tab:
Prompt
Say what you want to add or change, in plain language.
Watch
The live preview rebuilds in the browser as Lovable writes the code.
Try it
Click through the real app, with real buttons, forms and data rather than a mockup.
Refine
Select what’s off and describe the fix, or ask for what’s next.
None of that requires a computer science background or writing code, and the whole build happens in one browser tab, one request at a time.
Data & backendhandled automatically
Connect your database in a single step, right from the chat. Lovable builds the tables, sets up the logins, writes the server-side functions, and turns on live updates, each one an ordinary request in plain language, not a separate tool to learn.
Click to point instead of describing where
Select any element in the live preview with Lovable’s Select elements tool, and your next message applies to exactly that piece.
Full ownership and complete privacy
The app and the records in it are yours. Every change is saved automatically, and the repository Lovable syncs to GitHub is private on every plan, with no technical setup and not one Git command.
Pay a developer, or do it with AI
Nothing in a tutor you own carries a price per learner, so the cost is whoever writes it, plus a model bill that follows your own AI key and grows with practice rather than with sign-ups. Both ways of paying for the writing are priced below.
Hire a developer
Custom build, from scratch- Developer
- ~$9.8k-$39k
- Supabase (backend)
- Free tier · $25/mo (Pro plan)*
- Hosting
- $0 free tier
- AI tutor calls
- Per token on your own key
- Build time
- ~195 hrs of their work
~$9.8k-$39k to build, then from $25/mo after launch
Our ~195-hour estimate, costed against the rate survey linked below, whose bands run from $45-$75/hr for North American contractors up through $100-$150+/hr for senior US developers, before the 20-40% an agency adds, which brackets the range at roughly $50/hr and $200/hr. Most of those hours are the tutor prompt, the generated drills and the streak arithmetic, none of which shows in a screenshot. Then read the model row: at the default model’s rates a lesson of twenty exchanges costs well under a cent, and it is the only line that grows with use.
Build it with Lovable
From scratch, with Lovable- Lovable
- Free (30 credits/mo) to $25+/month (Pro, from 100 credits)
- Backend (Supabase)
- Free tier · $25/month (Pro plan)*
- Hosting
- $0 on a Lovable subdomain
- Your time
- ~94 hrs
Free to try the idea, ~$25-$50+/month on Pro while you build a real one, then whichever credit tier you keep using
Lovable bills by credits, so what you pay tracks what you build: importing the pre-built template can fit inside the Free plan’s 30 credits a month, while a full from-scratch build burns through Free fast and usually needs Pro. Pro’s entry rung is $25/month (or $250/year, roughly $21/month effective) for 100 credits, the bottom of a ladder where 200 credits runs $50/month (or $500/year, about $42/month), and a multi-session build often lands on that rung or higher rather than the entry price.
* On this template the free-tier line to watch is the pause rather than storage. Nothing large is stored, because conversations are not saved and no files are kept, so a learner is a few rows of text. What bites is that a free project sleeps after a week without activity, and a tutor people open when they have ten spare minutes is exactly the sort that goes quiet. Pro, from $25/mo, ends the pause and keeps a daily backup for 7 days.
Prices and rates from supabase.com, developex.com and docs.lovable.dev, checked September 2026.
Decide before you build
Six decisions to make before writing code. Two of them protect your AI key from a learner who practises more than you budgeted for, and one decides whether the tutor can hear.
What is your ceiling on tutor calls per learner?
Every reply, card and exercise is a paid call on your key, and the template ships with no limit on any of them. Decide now how many calls a learner gets per day or per month, what the screen says at the limit, and whether a paying learner gets more. Decided now it is a field on a table. Decided after the first surprising bill it is a rewrite.
Which languages and levels do you offer?
The template ships six languages in a fixed list and detects the learner’s native language from their browser. The model can teach far more, and each one you add is a line in a list plus a native speaker to check what it generates. Decide the list before the first screen, because it shapes the picker, the prompts and your marketing.
Do you save conversations?
The template keeps the conversation in the tab and forgets it when the tab closes. Saving it lets a learner pick up where they stopped and lets you show progress, and it also makes you the keeper of everything they typed while learning. Decide which, and if you save, decide for how long and how a learner deletes it.
Text only, or speaking too?
The template reads a flashcard aloud with the visitor’s own browser voices and has no microphone anywhere. Speaking practice is a real build: recognising speech, scoring pronunciation, a fallback for browsers without a voice for the language. Decide whether it is in the first version, because it changes the tutor prompt and the dashboard.
What counts as a streak day, and in whose time zone?
A streak is the feature that brings learners back and the one that makes them angry when it breaks. Decide whether any activity keeps it alive or each activity has its own, when the day rolls over for a learner in another time zone, and whether a missed day can be repaired. Write the rule down before the arithmetic is written.
Free trial, demo shell, or sign-up first?
The template’s demo mode shows the dashboard to a visitor without an account and gives them no tutor, no cards and no streak, because all of those spend your key. Decide whether strangers get a few real exchanges, an invitation, or the shell. Whatever you choose, limits attach to the account, because accounts are free to create.
Comparing your build options
Building a chat box that answers in Spanish is fast. The hard part is everything behind it: a correction that teaches rather than rewrites, drills generated at the learner’s level, a streak that counts days honestly, and a ceiling on what each learner can spend. Here are three ways to build the exact same product.
A tutor that answers is an afternoon. The weeks go on making it teach: correcting a learner’s sentence without rewriting it, carrying the last ten turns into the next reply, generating cards and exercises that match the level rather than the dictionary, and a streak that counts a day the way a learner in another time zone expects.
A kit gives you a login page, a settings screen and a tab bar. It has never heard of a target language, a correction or a streak, so the tutor, the drills and the progress, which are the whole product, start from nothing.
You describe a screen or a rule and watch the running app change in the same tab, while Lovable designs the tables and the access rules behind it. The check that matters: type a sentence with a mistake into the preview and read whether the tutor corrects it or rewrites it.
Estimate your exact build timeframe
Customize your feature list below to see how build time changes. If you only need the tutor chat, or streaks are not part of your product, uncheck those rows to reduce the estimate.
Your estimate
94 hrs
start to finish
Based on the 6 of 6 features you’ve selected, plus ~21h of groundwork. Toggle any on the left to watch the number move, and open the groundwork row to untick what you have already, such as a database that is already running or going live if you are only building a mock-up for now.
A rough estimate, not a quote. Real time depends on how much you customize and how clean your data is.
Let’s set up the tools you need
Nothing gets installed, because the whole workspace is a browser tab. Three things to sort out before step 01, and a fourth worth adding once the project matters to you. After that, you build by describing what you want.
Lovable account
Nothing to download. Sign up with an email, Google, or GitHub account and you land straight in the chat where you describe what to build.
Sign up for LovableLovable subscription
Lovable bills by build credits, so the plan you need follows what you build. Free gives you 5 credits a day, capped at 30 a month, which is enough to try it rather than to finish an app. Pro is $25/month for 100 credits ($250/year, about $21/month), and that is the bottom rung: a build spread over several sessions usually lands on 200 credits at $50/month, or higher.
Compare Lovable plansSupabase project
Where your app keeps its data. Connect your own Supabase project from the chat, or let Lovable create one for you. Either way it designs the tables, adds the logins, and wires the screens to them from there.
Connect Supabase to LovableGitHub connection
Not needed to build anything, since Lovable keeps its own history of every change. Link a GitHub account and it also keeps a private repository in sync, so a copy of the real code exists outside the browser tab. Worth doing before the project is one you would hate to lose.
Set up GitHub syncOnly the first three are needed to start, and none of it touches your computer. From here, you describe what you want and Lovable builds it in the browser.
Build your language tutor, message by message
Everything below happens in one browser tab. Send a message, watch the preview rebuild, click through what changed, then send the next. One thing about the order: the ceiling on tutor calls goes in with the first corrected reply, because a long test conversation without a limit is a bill.
- 01
Set the ground rules, then connect Supabase
The tutor cannot answer without a server-side function, and the function needs somewhere to run, so the database comes first here.
PromptSet the rules and connect the backendBefore we build anything else, note the ground rules for this project: it is an AI language tutor, the vocabulary throughout is learners, target language, activities and streaks, every call to the AI provider goes through a server-side function with the key held where the browser cannot reach it and a per-learner limit checked first, and the browser never holds the key or decides the limit. Now connect this project to Supabase, and once it is linked design the tables. A profile per learner with their native and target languages, created on sign-up. Activity completions with a type and the learner’s local day. Streaks per activity with the current and longest run. A calls log for every model call with tokens and a cost estimate, and a settings table holding the daily limit per learner.
Say the limit rule in the first message. Left unsaid, an assistant will reasonably build the chat first and the limit later, and later is when the test conversation has already cost something.
- 02
Get the tutor answering in the preview, with the ceiling
One function, one corrected reply, and the log and the limit in the same message. Test it with a sentence that has a real mistake in it.
PromptBuild the tutor function and the ceilingAdd a server-side function called chat-assistant that calls my AI provider with the key held where the browser cannot reach it. It takes the learner’s message, their target and native languages and the last ten turns, and asks the model to reply in the target language at the learner’s level and then, in the native language, to point out up to three mistakes and how to fix them without rewriting the whole message. Before it contacts the provider it writes a row to the calls table and checks the learner’s calls today against the limit in settings, returning a friendly "you have reached today’s practice limit" when it is hit. Then build a simple chat screen in the preview that shows the conversation and renders the reply as formatted text.
A reply that quietly rewrites the sentence is a chatbot. A reply that says what was wrong and why is a tutor, and if the preview shows the first, send a follow-up about the prompt before building anything else on it.
- 03
Add logins and the access rules, then check them with the audit prompt
Ownership here is simple (every row belongs to one learner) which makes it easy to get right and inexcusable to get wrong.
PromptAdd logins and access rulesAdd authentication: email-and-password sign-up, login, logout and a profile row per learner created on sign-up, with signed-out visitors sent to the login screen. Then turn on row-level security for every table: a learner reaches only their own rows, and every insert and update needs an explicit check that the new row is not being filed under someone else. Make every function, including the ones that only record activity, refuse a caller who is not signed in. Then show me how to confirm a second learner gets nothing back for the first learner’s rows.
- 04
Bookmark, then ask for the dashboard, the drills and the dictionary
The dashboard is the screen learners live in and the one you will iterate on most. Bookmark first so a bad direction is one click back.
PromptBuild the dashboard and the drillsBookmark the current version first. Then build the learning dashboard as one page with a language picker and four tabs. Chat Practice uses the function from step 02. Flashcards calls a get-flashcards function that generates vocabulary cards for the target language and a chosen difficulty, flips to reveal the meaning and reads the word aloud with the browser’s own speech. Quick Exercises calls a generate-exercise-sentence function for fill-in-the-blank sentences checked as the learner types. Dictionary calls get-word-meaning and translate-text with one tap to swap the two languages. Every function goes through the same key, the same sign-in check and the same per-learner ceiling as the chat. Put my name and colours on it.
Expect to send several follow-up messages on this one screen. Select the element in the preview to point at what should move rather than describing where it sits.
- 05
Add streaks and the history page
The feature that brings learners back tomorrow, and the one that makes them angry when it miscounts. Decide the rule before it is written.
PromptAdd streaks and historyAdd an activity-completed function that records a completed activity for the signed-in learner and updates that activity’s streak: consecutive days extend it, a missed day resets it, and the longest run is kept, using the learner’s local day sent from the browser and checked on the server. Add a get-streaks function, show the four streaks as counters on the dashboard, and build a streak history page with a week view and charts of completions per day and per activity. Tell me exactly when a streak breaks so I can write it into the help text.
The time-zone question is the one to settle here. A learner whose streak resets at midnight in your city rather than theirs will stop trusting the number.
- 06Destination
Add settings and demo mode, then try it signed out and publish
Finish with the pieces around the lesson, try to spend your key as a stranger in the preview, then publish from the same tab.
PromptAdd settings, demo, and publishAdd a settings page for the learner’s languages and a password change, plus a usage panel showing their calls and estimated cost this period. Add a demo mode: a visitor who continues without an account sees the dashboard shell with sample content and clear prompts to sign up, and none of the functions accept a call from them. Then walk me through the whole thing in the preview: open the demo signed out and confirm nothing calls the provider, sign up, hold a ten-turn conversation with mistakes in it, drill a set of cards and an exercise, look a word up, check the streaks moved, then hit the daily limit on purpose and read what the app says. When it holds up, publish it.
Protecting your app: sign-in, learner progress, and your AI key
A language tutor holds three things worth protecting: each learner’s account and progress, whatever they typed while learning, and the key that pays for every reply. Here are the rules to follow before launching.
Use your backend’s built-in authentication
Sign-up, sign-in, sessions and password changes come from the authentication service attached to your database. Use it as it comes, because a language tutor gives you no reason to build identity logic of your own, and a hand-written version that is subtly wrong fails silently until somebody’s account is open to a stranger.
Ownership enforced in the database
The template ships 8 access policies over three tables, and the rule they enforce is the simplest possible: a profile, an activity record and a streak belong to one learner and nobody else reads or changes them. There are no roles, so everyone who signs in can do the same things, which is the right shape for a personal tutor and something to change deliberately if you add a teacher view.
Every tutor call requires a signed-in learner
The five functions that call the model refuse a caller without a valid session at the gate, so an anonymous visitor cannot spend your key by finding the address. The four that record activity and settings check the caller inside the function instead. Ask for the gate check on all nine, because an open AI endpoint is an invoice rather than a data leak.
A login is not a spending limit
The half this template leaves to you. Signing in decides whose practice spends your money, not how much of it. You want a log of every call, a quota per learner over a day or a month, and a hard stop that ends the lesson politely rather than an email that warns you afterwards. Treat an unmetered tutor as a security problem, because that is how it behaves.
Store the AI key server-side and say what leaves
The provider key lives in the function’s secrets and never in the app, where anyone could lift it. Then the part people skip: every sentence a learner types travels to your AI provider, and people practising a language write about their day, their work and their family. Say so to whoever signs in, and read your provider’s terms on what it does with what it receives.
The demo mode is a shell, on purpose
A visitor who chooses to continue without an account sees the dashboard and gets no tutor, no cards, no exercises and no streak, because every one of those would spend your key on somebody you cannot identify. If you want strangers to get a taste, give them a capped account rather than opening the functions.
Enable daily backups before real learners arrive
The free tier keeps no backups, so during the build your database is the only copy of every streak a learner has kept going. Daily backups kept for seven days start on Supabase Pro at $25/mo. Move to it before the first stranger signs up, because a lost streak is the one thing a learner will not forgive.
Review the access rules (row-level security policies) on every table. For each one, tell me in simple terms who can view, add, edit, and delete records, confirm that people can only reach their own data while the right roles can reach more, and flag anything left open that shouldn’t be.
Paste this into the chat before launch so Lovable checks nobody can see data they shouldn’t.
One rule outranks everything above it: your database service key and your AI provider key belong on the server only, never in the app a learner downloads and never in a repository. If either escapes, treat it as compromised, check your provider’s usage page for what was spent with it, and replace it the same day.
What speeds the build, and what slows it
Speeds the build
- One small request per message, such as a field, a screen or a rule, rather than the whole app at once
- Connecting your database before building screens that need real data, not after
- Using Select elements to point at the exact thing that should change, instead of describing its location in words
- Bookmarking a known-good version before a redesign or a change to the data model
- Reading each response before sending the next request, so small mistakes don’t stack up
Slows the build
- Asking for an entire app in one message instead of one screen at a time
- Building screens for data your database does not hold yet
- Describing which button or section to change instead of selecting it
- Skipping bookmarks, then scrolling far back through history to undo a bad change
- Approving several messages in a row without previewing what actually changed
Connecting GitHub (Optional)
Every change in Lovable is saved automatically without any technical setup. You only need to link GitHub if you want a private copy under your own control or plan to hand the codebase over to external developers.
What Git actually is
A recorder for a project: every change becomes a version you can go back to, and nothing is ever overwritten. GitHub is the service that keeps those versions online.
Lovable already saves every change
A new version is created each time Lovable changes your project. No save button, no Git command, and the full history is there to scroll back through.
Version history, Lovable docsReverting undoes the code, not your data
One click restores an earlier version of your code and redeploys it, but nothing already written to your database rolls back with it. A UI or logic change is safe to undo. A change that touched real records is not.
Bookmark before a big change
Before a redesign or a change to your data model, bookmark the version you are on: one click back instead of a long scroll through history.
Connecting it, if you want to
Open your project settings, pick GitHub, and authorise the account. Lovable creates a private repository and keeps it in sync both ways: changes in Lovable reach GitHub, and anything pushed to that branch comes back in. Free on every plan.
GitHub integration, Lovable docsIt’s also how you leave, if you ever want to
The synced repository is a standard Vite and React project: clone it, hand it to a developer, or deploy it yourself.
Deployment, hosting, and ownership, Lovable docsWhere to host your application
Hosting gives your app a home on the internet so anyone can open it via a web link. Choose a service below to make your site live. (Your database, logins, and business records are stored separately in Supabase, covered below).
| Host | Best for | Notes | Free tier |
|---|---|---|---|
| LovableBuilt in | Publishing from the chat | The project you have been previewing publishes itself, with nothing to configure and no account to open anywhere else. Free on any plan at a lovable.app address. Paid plans put it on your own domain: buy one through Lovable and the DNS is done for you, or point one you already own at it using the two records the setup screen shows. Certificate issued automatically either way. | Free on a lovable.app subdomain · own domain on paid plans |
One button, and the app you have been previewing is live.
Hosting it somewhere else
Only for a setup Lovable does not offer: a host you already pay for, or the exported code on your own account. None of it is needed to go live.
| Host | Best for | Notes | Free tier |
|---|---|---|---|
| Vercel | One-click deploys | Publishes on every push once the repository is connected, and the template already ships the routing file that lets a bookmarked streak page open directly. Hobby is licensed for personal use only, and a tutor that students or staff sign in to is commercial by any reading, so it belongs on Pro at $20/user/mo. | Pro from $20/user/mo (Hobby is non-commercial) |
| Netlify | Drag-and-drop or Git | Link the repository, or drop the built folder onto the page and be live inside a minute. Say yes to the redirect rule it offers, because without it a learner’s bookmarked streak page lands on a not-found screen. | Free tier |
| Cloudflare Pages | Learners in more than one country | Served from the location nearest each learner, and people learning a language are rarely all in one country. The whole app is a small static folder, so the first screen arrives quickly even before the tutor has said a word. | Generous free tier |
| GitHub Pages | Not really this app | Publishes straight from a GitHub project after one routing change, and it is listed to be ruled out rather than chosen: the free tier requires a public repository, and this project sits beside function secrets nobody should be able to browse. | Free from a public repo only |
| Firebase Hosting | Teams already on Google | A short setup, then one command per release, with the deep-link rewrite declared in its own config file. Nothing about a language tutor argues for it, so choose it when your other accounts already live with Google. | Free Spark tier |
| AWS Amplify Hosting | Teams already on AWS | Publishes from the AWS console and wants the same rewrite rule as the others before a bookmarked page resolves. Pick it because your billing already lives on AWS, and for no other reason. | Free tier (build + hosting) |
| Surge | Publish from the terminal | A single command puts the built folder online with no repository involved, which is fine for showing a colleague the tutor and wrong the moment a real learner signs in and starts spending against your key. | Free - unlimited publishing |
| DigitalOcean App Platform | DigitalOcean users | Builds and serves from an account you already pay for, which for a small school or team means one supplier fewer beside your database and your AI provider. | Free - 3 static sites, 1 GB/mo transfer |
Choose on two things, neither of them speed. First, whether the plan permits commercial use, because Vercel’s Hobby tier does not and a tutor with paying learners is a business. Second, whether a bookmarked link to the streak page opens the app for a learner arriving cold, because their own progress is the page they bookmark. The tutor itself never touches the host: every reply comes from your database’s functions, and the host serves one small static folder.
The speaker button uses the visitor’s own browser voices, and a voice for the language may not exist on their device. The flashcards read a word aloud with whatever voices the browser and the operating system provide, so the accent varies from phone to phone and a language can come out in the wrong voice or not at all. Before you launch, press the speaker on every language you offer on a phone as well as a laptop, and decide what the button does when no voice is available rather than letting it silently do nothing.
Keep your data in Supabase
Learners, their activity and their streaks, plus the functions that call your AI provider, which is where the key belongs and the only place it should ever be.
| Service | Best for | Notes | Free tier |
|---|---|---|---|
| Supabase | Data, auth, and the tutor calls | Profiles, activity and streaks in Postgres, accounts from its auth service, and one edge function per AI job with the provider key in its secrets. Make a free project, hand over the URL and publishable key, and it is connected. Nothing large is stored, so the line to watch is not storage but the pause: a free project sleeps after a week without activity, and a learner who comes back on Monday finds a tutor that takes a moment to wake. | Free tier, then usage-based |
Add AI capabilities in one simple step
Securely route your AI API keys through a lightweight serverless function. Use simple prompts to automatically cap what each learner can spend, let them speak instead of type, place them at the right level, and schedule what they should review.
Log every call and put a ceiling on it
Nothing in the template records what the tutor was asked or what it cost, and nothing stops a learner from asking all day. Build this before anything else below, because everything below spends money too.
Add a calls table that records every model call (which learner, which activity, which model, how many tokens went in and came back, whether it succeeded, and a cost estimate) and write to it from every function that calls the provider, successful or not. Then add a ceiling: a limit per learner per day and a total across the whole app, both settings I can change without a deploy, checked inside the function before it contacts the provider and returning a friendly "you have reached today’s practice limit" rather than an error. Do not let the client send the limit or the cost, because both are read on the server. Then add a small usage panel in settings showing calls and estimated spend for the current period.
Let the learner speak instead of type
The tutor reads cards aloud today and cannot hear. Speaking is what most learners are actually afraid of, and the browser can listen for you, with the honest caveat that the recognition may use the platform’s own service rather than run on the device.
Add a microphone button to the chat and the exercises that uses the browser’s speech recognition to turn what the learner says in the target language into text, shows the transcript for them to correct before it is sent, and falls back to the text box in browsers that do not support recognition for that language. Then extend the tutor prompt so that when a message arrived by voice, the reply also comments briefly on any word the transcript suggests was mispronounced, without turning the lesson into a pronunciation drill.
Place the learner at the right level
A beginner and an intermediate learner get the same cards today unless they pick a difficulty themselves. A short placement conversation decides it for them, and the tutor adjusts as they improve.
Add a five-exchange placement conversation for a new learner in their target language, send the transcript to the ai function and ask for a level on a simple scale with a one-line reason, store it on the profile, and use it as the default difficulty for flashcards and exercises. Re-evaluate every twenty completed activities and tell the learner when their level changes, letting them override it.
Schedule what to review
Cards are generated fresh each time and nothing remembers which ones the learner got wrong. Saving them and bringing the hard ones back at the right interval is the difference between a game and a study tool.
Save every generated flashcard and exercise to the learner’s account with whether they got it right, then add a "Review" tab that schedules cards with spaced repetition: the ones they missed come back tomorrow, the ones they knew come back in a week, then a month. Ask the ai function to generate a fresh example sentence for each card on its review day so the same word is met in a new context, and show the learner how many cards are due today on the dashboard.
You bring no key and pick no provider: Lovable manages an API key per project, and if you do not name a model it chooses one from what you describe. Match the model to the job: fast and cheap for anything that runs on every record, stronger only where the reasoning matters. Send every feature above through that one integration.
Get a head start with our template
Everything above starts from an empty folder, and it does not have to. The same tutor exists already built: the chat corrects, the cards and exercises generate, the dictionary answers and the streaks count, so your time goes on the languages, the tutor’s manner and the name on the door.
AI Language Tutor
The exact language tutor this guide builds, packaged so you can open it, point it at your own backend, and make it yours from there. Learn a language by chatting with an AI tutor that corrects you as you go, then practice until it sticks. Chat for real practice, look up meanings and translations, drill with flashcards and exercises, and keep a daily streak going.
The key benefits of starting with a template
The tutor chat, the drills, the dictionary and the streaks already work. Behind them, sign-in, the access rules, settings and a demo shell are done too. Read the security section above before you go live, because the ceiling on tutor calls is the one thing this template leaves to you.
Building the core from scratch
~94 hrs
Opening the template, already built
~1 hr
Pay Once, Own Forever. Build exactly what your team needs without renting a monthly SaaS subscription, paying per-seat fees, or dealing with platform lock-in.
A tutor that corrects, already prompted
The conversation function replies in the target language, marks the learner’s mistakes and carries the recent turns forward, and the reply renders as formatted text. Writing that prompt so it teaches rather than rewrites is the part a first attempt gets wrong, and it is done.
Drills generated for the level
Flashcards and fill-in-the-blank exercises come from the model for the chosen language and difficulty, with the cards read aloud by the browser. No deck to author before the first learner arrives.
A dictionary and translator in the lesson
Meaning and translation from the same dashboard, both directions, one tap to swap languages, each through its own function with the key held on the server.
Streaks with a history page
A streak per activity recorded when something is completed, counters on the dashboard, and a week view with charts on its own page, all in the database rather than in the browser.
Accounts, access rules and a demo shell
Email sign-in with a profile per learner, 8 access policies holding each learner to their own rows, settings and a password change, and a demo mode that shows the dashboard to a visitor without spending your key. There are no roles, so add a teacher view deliberately if you need one.
From founders who build on our templates
We needed a working product in front of users fast. I started from one of these templates instead of a blank repo, customized it in our AI tool, and shipped in days - not the weeks it usually takes.
Jeevan ThomasFounder & CEO, Hado.aiCommon questions
Cents, at the default model’s rates. A message and its corrected reply are a few hundred tokens, so twenty exchanges cost well under a cent, and a set of flashcards or exercises is about the same. The bill grows with practice rather than with sign-ups, which is why the first prompt in the AI section puts a ceiling on it: a learner who chats all day is the one case where cents add up.
Different, and honestly so. A course written by people and recorded by native speakers teaches a beginner more reliably than a generated deck. What the tutor does that a course cannot is read what the learner actually wrote and correct it, and practise a conversation the learner chooses. Most people who build this run it beside teaching, not instead of it.
The template ships six in a fixed list (Spanish, French, English, German, Mandarin and Japanese) and detects the learner’s native language from their browser. The model can tutor many more, and adding one is a line in the list, with the honest caveat that generated content in a language you do not speak needs a native speaker to check it.
Not as shipped. The flashcards read a word aloud using the visitor’s own browser voices, and the template has no microphone, recording or pronunciation scoring anywhere. Speaking practice is the second prompt in the AI section, built on the browser’s own speech recognition, and it is a real piece of work rather than a toggle.
Not in the template. A conversation lives in the tab and is gone when it closes, which keeps the database tiny and means you hold nothing a learner typed. Saving conversations so a learner can pick up where they left off is a decision above, and it makes you the keeper of everything they said while learning.
No. Describe what you need in plain language and your AI coding tool writes the tables, the accounts, the access rules and the functions that call the model. Your own job is creating a free Supabase project for it to point at and putting your AI key in its secrets, so the records and the key end up somewhere you own.
Less than a course subscription for anything above a handful of learners, because the price per learner is missing. What is left is Supabase and a host, both starting free, with Supabase Pro from $25/mo once real people sign in and you want backups and no pause, plus the model bill on your own key, which runs to cents per lesson.
Only that learner. Every profile, activity record and streak belongs to one account and the database enforces it on every query rather than trusting the screen to filter. There are no roles as shipped, so a teacher who wants to see their students’ streaks is a feature to design rather than a setting to switch on.
They can see it. The template’s demo mode shows the dashboard to a visitor without an account and gives them no tutor, no cards and no streak, because every one of those would spend your key on somebody you cannot identify. If you want strangers to get a few real exchanges, give them a capped account instead.
As shipped, only their patience. Every model call requires a signed-in learner, so strangers cannot spend your key, but nothing caps how much a learner may ask. The first prompt in the AI section adds a log of every call and a limit per learner per day, and this guide treats it as part of the build rather than an option.
Nothing here is proprietary. Learners, activity and streaks live in ordinary PostgreSQL, so a standard dump gives you everything in a form any Postgres host accepts, and the tutor prompts are plain text in the functions.
Yes. Every host here connects a custom domain with free HTTPS in a few clicks. Worth doing before you invite anyone, because a tutor students sign in to every day should look like it belongs to you.
No. Everything happens in a browser tab: you describe what you want in the chat, and Lovable writes and previews the code. The setup section above covers the handful of things you connect first: an account, a plan, and your own Supabase project.
A sketch on the Free plan is fine for testing an idea, with no real backend behind it. A project connected to your own Supabase account is the one you can actually launch, with real logins, real data, and your own domain.
Build credits reset every day (Free) or on your billing cycle (paid plans). If you run out mid-session, the app you’ve built stays exactly as it is. You either wait for the reset or move up a credit tier to keep going right away.
References
Sources checked September 2026- 01Pricing (monthly and yearly, all 25 languages), Rosetta Stone. rosettastone.com
- 02Pricing (individual and family plans), Mango Languages. mangolanguages.com
- 03Pricing (monthly, 6-month and 12-month plans), Ling. ling-app.com
- 04Premium pricing (monthly, yearly and lifetime), Drops. languagedrops.com
- 05API pricing (per-token rates for the default tutor model), OpenAI. developers.openai.com
- 06Web Speech API (speech synthesis and recognition in the browser), MDN. developer.mozilla.org
- 07Pricing (Pro plan, pause, backups), Supabase. supabase.com
- 08Web developer hourly rates 2026 (freelance and agency benchmarks). developex.com
- 09Row Level Security, Supabase docs. supabase.com
- 10Sign up, Lovable. lovable.dev
- 11Subscription plans (Free, Pro, Business), Lovable docs. docs.lovable.dev
- 12Connect Supabase, Lovable docs. docs.lovable.dev
- 13GitHub integration, Lovable docs. docs.lovable.dev
- 14Deployment, hosting, and ownership, Lovable docs. docs.lovable.dev
- 15Version history and reverting, Lovable docs. docs.lovable.dev
- 16Preview toolbar (Select elements), Lovable docs. docs.lovable.dev
- 17AI features and model selection, Lovable docs. docs.lovable.dev
- 18Custom domains, Lovable docs. docs.lovable.dev
This guide is general information. Third-party prices, plan limits and market rates are quoted from the sources above and were last checked on the date shown. Vendors change them without notice, so confirm before you budget. What a generated lesson costs depends on your provider’s current rates and how much your learners practise, so treat any cost expectation here as a starting point to measure rather than a specification. Build hours and the cost estimates derived from them are our own estimates, not quotes. Lovable is a product of Lovable Labs. Verify current capabilities and pricing before relying on them.