How to build an AI language tutor for your business with Replit (no coding required)
Build a language tutor in one Replit workspace, from the first message to the day learners start practising in it. 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 your own AI key, with progress saved to a database set up for you and published from the same tab.
Replit
$ Build me a language tutor: learners chat with a tutor that replies in their target language 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. Add a database for their progress, cap what each learner can spend on my AI key, and keep each learner’s work to themselves.
- Database provisioned in the workspace
- Tutor and drills built
- Ready for you to publish
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 Replit
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.
Replit’s Agent handles the database, the access rules, and the hosting from one chat, in the same workspace the app ends up living in:
Describe
Tell the Agent what to build, in plain language.
Watch
It writes the code, sets up the database, and shows the app running live.
Try it
Use the real app in the preview rather than a mockup.
Publish
Take it live on Replit’s own hosting, or ask for the next change.
The build and the place it ends up running are the same workspace throughout, so there’s no separate hosting account to set up later.
One workspacebuilds, runs, and hosts it
Replit is the one tool here that also deploys what it builds. Publishing takes the same project live on Replit’s own infrastructure, with a working domain, uptime monitoring, and security scanning included.
Managed Postgres with 20GB included free
Ask the Agent to add a database and it creates the schema and wires your app to it. What you get is a real, fully-managed SQL database rather than a mocked one.
Up to 10 Agent sessions in parallel (Pro)
Core allows up to 2 parallel Agent sessions and Pro allows up to 10, so more than one part of the app can be worked on at the same time.
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 Replit
From scratch, with Replit- Replit
- Free (daily credits) to $25/month (Core) or $100/month (Pro)
- Database (built-in Postgres)
- Free to start · 20GB included
- Hosting (Replit Deployments)
- Billed separately, on top of the plan
- Your time
- ~94 hrs
Free to try the idea, ~$25-$100/month on Core or Pro while you build a real one, then whichever plan (plus any deployment cost) you keep using
Replit’s plan price and its credit grant are the same number, not a subscription plus a separate credit purchase: Core is $25/month for $25 of monthly credits (or $20/month billed annually), Pro is $100/month for $100 of monthly credits (or $95/month annually). Once you publish, Replit bills hosting through its own Deployments separately, on top of whichever plan you’re on. Budget for it as a second line, not folded into the $25 or $100.
* 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 replit.com, 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 ask the Agent for a piece at a time and it writes the database, the server and the dashboard in the same workspace that ends up hosting the finished app. The check that matters: sign in as a second learner on the published address and confirm the first learner’s streaks never appear.
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
Replit runs entirely in the browser, and it’s the one tool here that also hosts what you build, so no GitHub account is required first. Before step 01: an account and a plan. A database comes later, the moment your app actually needs one, and GitHub whenever you want a copy of the code outside Replit.
Replit account
Sign up and you land in a workspace with an Agent chat, the code, and a live preview side by side, with nothing to install.
Sign up for ReplitReplit subscription
Starter’s free daily credits are enough to try an idea, not to finish one. Core is $25/month billed monthly, or $20/month billed annually, for $25 of monthly credits and up to 2 parallel Agent sessions. Pro is $100/month monthly, or $95/month annually, for $100 of monthly credits, more collaborators, and access to the strongest available models. The price you pay and the credits you get are the same number on both plans, so you have no separate subscription-plus-credits split to work out.
Compare Replit plansReplit database (Postgres)
Every Replit app includes its own managed Postgres database with 20GB of free storage. Ask the Agent to add one and it creates the schema and connects your app to it, with no separate account to create anywhere else.
Replit’s built-in database, Replit docsGitHub connection
Not needed to start, and not needed as an undo either, because Replit checkpoints the whole workspace as the Agent works. Connect a repository from the Git pane, free on every plan, and a copy of the real code lives outside Replit under your own account. Worth doing once the project is one you would hate to lose.
Using the Git pane, Replit docsThe first two are all you need to start. Everything here stays inside the one browser tab, the app included once you publish it, and the GitHub copy is the one deliberate exception.
Build your language tutor, one Agent message at a time
Nothing installs and nothing gets connected from outside. The Agent writes the files, runs the commands, and provisions the database as it goes. One thing to keep in mind throughout: every reply the tutor gives is a paid call on your key, so the ceiling goes in with the first one.
- 01
Start the app, ask for the database, and set the rules
The database comes free with the workspace, so it goes in the opening message. So do the two constraints that matter most on this build.
PromptSet up the project and the databaseSet up a React 18 + Vite + TypeScript app with Tailwind, and add a Postgres database to this Repl, the one Replit provisions, not anything outside. Write a short notes file at the project root saying this is an AI language tutor, fixing the vocabulary as learners, target language, activities and streaks, and recording two standing rules: every call to the AI provider goes through a server route with the key in Replit’s Secrets and a per-learner limit checked first, and the browser never holds the key or decides the limit. Keep the database connection details in Secrets rather than in the code.
The rules are worth writing into the notes file rather than a single message. Calling the provider from the browser is a natural suggestion for any assistant, and it would put your key in every learner’s hands.
- 02
Get the tutor answering in the live preview, with the ceiling
One route, one corrected reply, and the log and the limit in the same message. Roll back to a checkpoint if the prompt goes sideways rather than unpicking it.
PromptBuild the tutor route and the ceilingAdd a server route that calls my AI provider with the key held in Replit’s Secrets. 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 contacting the provider it writes a row to a calls table (learner, activity, model, tokens in and out, cost estimate) and checks the learner’s calls today against a limit read from a settings table, returning a friendly limit message when it is hit. Build a simple chat screen in the preview that renders the reply as formatted text, with a placeholder learner id for now.
Check the correction in the live preview with a sentence that has a real mistake in it. Whether the tutor teaches or rewrites is decided in the prompt the Agent wrote, and it is a one-message fix now.
- 03
Add sign-in and scope every row to its learner
Replit’s Postgres is a plain database with no login wired into it, so the Agent writes both halves: sessions on the server, and policies the server’s identity feeds.
PromptAdd sign-in, tables and access rulesAdd email-and-password sign-up, login, logout and a server-side session, with a profile row per learner holding their native and target languages. Then the tables. Activity completions with a type and the learner’s local day. Streaks per activity with the current and longest run. Wire the calls and settings tables from step 02 to the real learner id. Then turn on row-level security across every table: have the server set the current learner as a session-local setting at the start of each request, write the policies against that setting so a learner reaches only their own rows, make every route including the ones that only record activity refuse a caller without a session, and show me how to verify a second learner comes back empty for the first learner’s rows.
There is no ready-made login handing the database a user id here, so the server is what knows who is asking. Build that first and the policies have something to read.
- 04
Build the dashboard, the drills and the dictionary
The screen learners live in. Check the preview after each change here rather than stacking several and finding out which one broke a tab.
PromptBuild the dashboard and the drillsBuild the learning dashboard as one page with a language picker and four tabs. Chat Practice uses the route from step 02. Flashcards calls a route 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 synthesis. Quick Exercises calls a route for fill-in-the-blank sentences checked as the learner types. Dictionary calls one route for a word’s meaning and one to translate a phrase, with one tap to swap the two languages. Every route goes through the same key, the same session check and the same per-learner ceiling as the chat. Put my name and colours on it.
This is the step where checkpoints earn their keep. A tab that worked two messages ago and does not now is a one-click problem rather than an afternoon.
- 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 a route 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 route that returns the four streaks, show them 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.
- 06Destination
Add settings and demo mode, then publish
Finish with the pieces around the lesson, then publish, checking who the app is visible to before that first release, since Publishing is what sets it.
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 no route accepts a call from them. Then help me test the whole flow: open the demo signed out and confirm nothing calls the provider, sign up, hold a ten-turn conversation with mistakes in it, drill cards and an exercise, look a word up, check the streaks moved, hit the daily limit on purpose and read what a learner sees. When it holds up, walk me through Publishing: which deployment type fits an app whose server is small and whose calls are metered, and who the app should be visible to.
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 on this tool.
Logins your server owns
There is no hosted identity service in this workspace, so sign-up, sign-in, sessions and password changes are code on your own server rather than a product you switch on. Use a well-known library rather than writing password handling yourself, and treat the session as the thing that decides everything else in this list.
Ownership enforced in the database
A profile, an activity record and a streak belong to one learner and nobody else reads or changes them. The policies apply that on every read and write, so a screen that forgets to filter still cannot show one learner another learner’s progress. There are no roles, so add a teacher view deliberately if you need one.
Where the checking actually happens
Your server declares who is asking by setting a session variable on the connection before each query, and the row-level policies read it. Two things follow. The declaration has to be set on every request rather than once at startup, because connections are reused between people. And a policy reading a variable nobody set does not complain, it just admits everybody.
Every tutor call requires a signed-in learner
Every route that calls the model refuses a caller without a session, so an anonymous visitor cannot spend your key by finding the address. Check this first on any route you add, because an open AI endpoint is an invoice rather than a data leak.
Count the ceiling in the database, never in memory
An autoscaling deployment runs more than one copy of your server under load, so a per-learner counter held in a variable is per copy and resets whenever a new one starts, which is precisely when a class has just logged in. Count in Postgres, where every copy sees the same number, and stop the lesson politely when it is reached.
Store the AI key in Secrets and say what leaves
The provider key lives in Replit’s Secrets tool, readable by your server and absent from anything the browser downloads. 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 continues 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 routes.
Backups, and how far back you can go
The Agent checkpoints as it works (files, configuration and optionally the database) so a bad change is a click back rather than an afternoon. Check what your plan retains for this workspace’s Postgres before you rely on it, and take your own dump on a schedule if the answer is thinner than you assumed, 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 the Agent checks nobody can see data they shouldn’t.
One rule outranks everything above it: the database connection and your AI provider key belong in Secrets only: never in anything the browser downloads, and never in a repository. If either gets out, treat it as compromised and rotate it the same day.
What speeds the build, and what slows it
Speeds the build
- One small, specific request per message, checked in the live preview before the next one
- Letting the Agent provision the database from the chat instead of wiring one up by hand
- Running two Agent sessions in parallel on unrelated parts of the app, once your plan allows it
- Rolling back to a checkpoint the moment a change goes wrong, instead of unpicking it by hand
- Reviewing what Publishing changed, meaning the domain, who can reach the app, and the machine it runs on, before the first release
Slows the build
- Asking for the whole app in one message instead of one piece at a time
- Building screens for data that isn’t in the database yet
- Running unrelated Agent sessions against the same files at the same time
- Letting several risky changes stack up before checking whether any of them actually broke something
- Publishing without checking who the app is visible to first
Connecting GitHub (Optional)
Every change in Replit is saved automatically without any technical setup. Checkpoints are the day-to-day undo. 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.
Every milestone is already saved
Replit’s Agent creates a checkpoint automatically at key points as it works: a full snapshot of the files, the configuration, and even the AI conversation itself, not just the code.
Checkpoints and rollbacks, Replit docsRolling back restores the whole workspace
One click returns your project to an earlier checkpoint (files and configuration together, and optionally the database), which is broader than a typical code-only undo, so a rollback after real data has changed is worth a second look before you confirm it.
GitHub keeps a copy outside Replit
Connect a repository from the Git pane, free on every plan, and stage, commit, and push changes back to GitHub with a click, or pull in anything changed outside Replit.
Using the Git pane, Replit docsIt’s also how an existing project gets in
Point Replit at a public repository’s URL for a fast import, or use the guided import for a private one. Either way, Replit detects the stack and installs everything on its own.
Import from a provider, Replit docsYou rarely type git commands
The Git pane’s buttons cover staging, committing, and pushing. If you’d rather type them yourself, the workspace Shell stays in sync with whatever the pane just did.
Going live without external hosting
Skip third-party hosting and external database setup. Your database, backend, and domain live in the same Replit workspace. Just click Publish to go live.
| Host | Best for | Notes | Free tier |
|---|---|---|---|
| Autoscale | Most language tutors | Grows with traffic and shrinks to nothing when nobody is practising, which suits an app people open for ten minutes at a time. Confirm the daily limit is counted in the database rather than in one process’s memory, since more than one copy of the server can be running when a class logs in at once. | Metered - billed with your plan |
| Reserved VM | Classes on a schedule | Dedicated compute that never sleeps, so nobody waits on a cold start before their tutor answers. Worth it once a school or a team uses the tutor at the same hour every day, and less urgent for learners who drift in through the evening. | By machine size - billed with your plan |
| Scheduled | The nightly streak sweep | Runs on a timer rather than answering requests, which is the right shape for a job that resets streaks nobody kept alive yesterday and totals the day’s model spend for you. It publishes separately from the app. | Metered - billed with your plan |
| Static | Not this app | Files only, with no server behind them. Ruled out here, because the routes that hold your key, enforce the ceiling and record streaks are the server, and none of them exists on a static deployment. | Metered - billed with your plan |
All four are Replit rather than a third party, so the choice is shape rather than vendor, and Autoscale suits most of these apps. Two things specific to this build: the server is small, because the model does the heavy work on your provider’s side, and the one number that must be right across every copy of it is the per-learner ceiling, so count it in Postgres. Review who the app is visible to before that first release.
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 publish, 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.
Your database is already part of the workspace
Nothing to connect. Learners, their activity and their streaks are small rows of text, so this is one of the least demanding databases in the catalogue, and no files are stored at all.
| Service | Best for | Notes | Free tier |
|---|---|---|---|
| Replit Postgres | Data, built in | Managed Postgres with 20GB included free, provisioned from the same chat that builds the app, and since it is ordinary Postgres the access policies from step 03 and the calls table the ceiling reads both work exactly as they would anywhere else. What it does not include is a hosted identity service, which is why your own server declares the learner before any policy can act on it. Conversations are not stored, so the storage figure is not the line to watch. The calls table is, because it is what the ceiling counts. | Free to start · 20GB included |
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.
A cheap model is plenty for most of the prompts above. Save Pro’s stronger models for the one or two spots where the extra reasoning actually pays for itself. Add any provider key through Replit’s own Secrets tool rather than hard-coding it, and keep every AI feature behind one server-side function so a single key covers the whole app.
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. Tables, sessions, access rules and the server routes that call the model all get written from plain-language prompts, and the database they write into is created inside this workspace when you ask. Your own job is putting your AI key in Secrets, so the key ends up somewhere only your server can read.
Less than a course subscription for anything above a handful of learners, because the price per learner is missing. What is left is your Replit plan. Core starts at $25/month, or $20/month billed annually, with 20GB of database included, Publishing billed separately on top, and 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 routes.
Yes. The replit.app subdomain it starts on can be replaced with your own through Publishing, HTTPS included. Do it before you invite anyone, because a tutor students sign in to every day should look like it belongs to you.
No. You describe what you want in the chat, and the Agent handles the rest: the code, the database, and a live version of the app right there in the workspace. The setup section above covers the account and plan you need first.
Replit hosts it. Publishing takes the same project live on a Replit domain, or your own if you connect one, with monitoring and access controls included, so you never open a separate hosting account.
Starter’s daily credits and a paid plan’s monthly grant both refill on their own schedule. Hitting either limit mid-build doesn’t touch what you’ve already made. Move up a plan for more headroom right away, or wait it out.
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
- 09Pricing (Starter, Core, Pro), Replit. replit.com
- 10Built-in database, Replit docs. docs.replit.com
- 11Publishing overview, Replit docs. docs.replit.com
- 12Deployment types, Replit docs. docs.replit.com
- 13Checkpoints and rollbacks, Replit docs. docs.replit.com
- 14Using the Git pane, Replit docs. docs.replit.com
- 15Import from a provider, Replit docs. docs.replit.com
- 16Secrets, Replit docs. docs.replit.com
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. Replit is a product of Replit, Inc. Verify current capabilities and pricing before relying on them.