Can OpenPTE be vibe coded?
Online PTE Academic practice platform: exam-style speaking, writing, reading and listening tasks with automated scoring and feedback.
The mechanics of a PTE trainer are not hard: record audio, transcribe it, time the task, score against a rubric, keep a history. An agent can build that in a focused implementation using Whisper for transcription and an LLM for rubric feedback, and you will genuinely practice more because the loop is yours. What you cannot build is the part people actually pay for: a question bank that tracks what is currently showing up in the real exam, and a scoring model calibrated against Pearson's automated marker so the number you see means something. Your DIY grader will be directionally useful and numerically fictional. Good enough for drilling fluency and essay structure, not good enough to decide whether you are ready to book the test.
Jump to the build brief ↓Legacy-calibrated assessment
Checked Aug 2026
What you pay today, before any DIY hosting
low editorial confidence
Tracked separately from the pricing check
Buildability by layer
Screens, forms, and focused interactions
The repeatable job the product performs
Availability and legality of required data
Uptime, queues, support, and maintenance
Security, compliance, and user confidence
The achievable core
- A local web app that runs timed PTE-style tasks, records your speaking or captures your typing, transcribes it, and returns rubric feedback plus a trend chart across attempts.
- Sequence lessons, check understanding, and track progress for one learner.
- A responsive interface with real empty, loading, success, and error states.
The parts a prompt cannot buy
- Scores calibrated to the real automated marker, so your numbers are vibes, not predictions
- A question bank that is maintained and rotated as the exam changes
- Full mock tests with official section timing, weighting and score report layout
- Model answers, templates and community discussion around each item
- The useful dataset is owned, accumulated, or expensive to reproduce.
- Model quality and inference operations are part of the product.
Build, switch, or keep paying
Narrower, with trade-offs
A local web app that runs timed PTE-style tasks, records your speaking or captures your typing, transcribes it, and returns rubric feedback plus a trend chart across attempts.
Use the build brief ↓No checked option yet
Compare the prior art below or build only the workflow you need.
$17.99/mo
Because a test taker is not buying software, they are buying a number they can trust before they pay the exam fee. A prep platform's value is the item bank that mirrors what is currently in circulation and a grader tuned so a 79 on the practice test means roughly a 79 on the day. Both of those are accumulated data work, not code. A self-built trainer is great for volume practice and terrible for readiness signals, which is exactly the wrong half to have if you only get one shot at the visa cutoff.
Visit OpenPTE ↗Why people still pay
Because a test taker is not buying software, they are buying a number they can trust before they pay the exam fee. A prep platform's value is the item bank that mirrors what is currently in circulation and a grader tuned so a 79 on the practice test means roughly a 79 on the day. Both of those are accumulated data work, not code. A self-built trainer is great for volume practice and terrible for readiness signals, which is exactly the wrong half to have if you only get one shot at the visa cutoff.
The useful dataset is owned, accumulated, or expensive to reproduce.
Model quality and inference operations are part of the product.
Licensed content and distribution rights are not reproducible with an LLM.
The brief
Context, requirements, acceptance criteria, non-goals, and the full production standard — as Markdown, ready for any coding agent.
Build brief — a focused alternative to OpenPTE
Context
OpenPTE — Online PTE Academic practice platform: exam-style speaking, writing, reading and listening tasks with automated scoring and feedback. It currently costs $17.99/mo.
The mechanics of a PTE trainer are not hard: record audio, transcribe it, time the task, score against a rubric, keep a history. An agent can build that in a focused implementation using Whisper for transcription and an LLM for rubric feedback, and you will genuinely practice more because the loop is yours. What you cannot build is the part people actually pay for: a question bank that tracks what is currently showing up in the real exam, and a scoring model calibrated against Pearson's automated marker so the number you see means something. Your DIY grader will be directionally useful and numerically fictional. Good enough for drilling fluency and essay structure, not good enough to decide whether you are ready to book the test.
This brief describes a focused, single-operator replacement for the part of OpenPTE that is genuinely reproducible. It is deliberately narrower than the product it replaces, and it says so in writing. Build the useful core; do not pretend to have rebuilt the rest.
What you are building
A local web app that runs timed PTE-style tasks, records your speaking or captures your typing, transcribes it, and returns rubric feedback plus a trend chart across attempts.
Sequence lessons, check understanding, and track progress for one learner.
A responsive interface with real empty, loading, success, and error states.
Requirements
Functional
Node 20 and a modern browser with mic permission.
Your own question set: prompts, images, and audio you supply as JSON.
Time to write the rubric prompts per task type, which is most of the actual work.
Data and integrations
An OpenAI-compatible API key in .env for transcription and rubric scoring, or a local whisper.cpp build.
Each of these needs a real account, credential, or quota. Set them up before writing feature code.
Non-functional
Accessibility: semantic markup, labelled controls, visible focus, and reduced-motion support.
Security: server-side secrets, validated input, and no credentials in the client bundle.
Reliability: retries with backoff on external calls, and a clear failure state when a provider is down.
Portability: the operator can export their data and leave without losing it.
Implementation brief
Build a local PTE Academic practice trainer. Empty folder, no accounts, no telemetry, no cloud database.
Stack, non negotiable: Next.js 15 with the App Router, TypeScript, Tailwind, and SQLite via better-sqlite3. Everything runs with npm run dev on localhost. Secrets in .env.local only, read OPENAI_API_KEY and OPENAI_BASE_URL.
Data: a questions/ folder of JSON files, one per task type, each item having id, type, prompt text, optional imagePath, optional audioPath, timeLimitSeconds, and preparationSeconds. Ship 3 dummy items per type so the app runs before the user adds real content. Do not scrape or invent exam content.
Task types to support: Read Aloud, Repeat Sentence, Describe Image, Retell Lecture (speaking, recorded), plus Summarize Written Text, Write Essay (typed), and Reading Fill in the Blanks (drag or select).
Practice flow: pick a task type, get a random unattempted item, show preparation countdown, then the recording or typing window with a hard timer that auto-submits. Use MediaRecorder for audio, store the webm blob under data/recordings/.
Scoring: for speaking, send audio to the Whisper transcription endpoint, then compute words per minute, filled pause count, and for Read Aloud a word level diff against the reference text. For writing, compute word count and run a rubric prompt. In both cases call the chat model with a task specific rubric that returns strict JSON: content, form, fluency, pronunciation or grammar, each 0 to 5, plus two sentences of feedback and three concrete fixes. Store the raw JSON.
Label every score in the UI as "unofficial, uncalibrated" and never render a 10 to 90 style score. This is deliberate.
History: an attempts table plus a dashboard with a per task type trend line, a list of past attempts with playback of the stored audio, and a CSV export.
Out of scope: full mock tests, official score mapping, user accounts, payments, mobile apps, sync, and any bundled question bank.
Deliver a README covering setup, how to add your own items to questions/, and a blunt paragraph on why these scores are not predictions.
Delivery standard
Inspect the repository first, then write a short implementation plan before writing code.
Deliver the smallest complete end-to-end workflow first; every primary control must work against persisted data.
Use real validation and storage; never substitute fake dashboards, decorative controls, hard-coded success states, or mock integrations.
Include responsive layouts plus genuine empty, loading, success, validation, and failure states.
Keep secrets server-side in environment variables, provide .env.example, and never commit credentials or user data.
Add structured logs around every external call and return actionable errors without leaking sensitive details.
Write unit tests for the core logic and one automated test of the main user journey.
Finish with a README covering setup, architecture, data location, backups, tests, deployment, and known limitations.
Acceptance criteria
A clean install starts the app using only the README and .env.example.
The primary journey works from first visit through saved result, reload, edit, export, and deletion where applicable.
Invalid input, missing configuration, provider failure, and an empty database each have a usable state.
The interface works at 390px and 1440px, is keyboard navigable, and shows visible focus on every control.
Tests, type checking, linting, and a production build all pass with no ignored failures.
No part of the interface implies a live integration, security guarantee, or scale capability that was not actually built and verified.
Non-goals
Do not build these, and do not claim to have replaced them:
Scores calibrated to the real automated marker, so your numbers are vibes, not predictions.
A question bank that is maintained and rotated as the exam changes.
Full mock tests with official section timing, weighting and score report layout.
Model answers, templates and community discussion around each item.
Mobile apps, cross-device sync, and anyone to blame when the grader is wrong.
What you still own after launch
Secure credentials, rotate secrets, and handle provider rate limits.
Run migrations, backups, restores, and dependency updates.
Test the critical journey after every model, API, or hosting change.
Monitor failures and fix the edge cases a first prompt will miss.
Risk
Operational risk. The code is achievable; dependable data, integrations, and ongoing operations are the real cost.
Editorial confidence in this assessment: low. No reviewed project implementation is linked yet.
Generated by Can It Be Vibe Coded? · Full report: https://www.canitbevibecoded.com/openpte
You still own the product
- Secure credentials, rotate secrets, and handle provider rate limits.
- Run migrations, backups, restores, and dependency updates.
- Test the critical journey after every model, API, or hosting change.
- Monitor failures and fix the edge cases a first prompt will miss.
Projects built from this idea
No reviewed implementation has been linked for OpenPTE yet. A submission is evidence for review, not automatic proof that the whole product was replaced.
Built a version of OpenPTE?Submit the project as evidence for this report.
Before you start
Can OpenPTE be vibe coded?
Partly, if you narrow it. The mechanics of a PTE trainer are not hard: record audio, transcribe it, time the task, score against a rubric, keep a history. An agent can build that in a focused implementation using Whisper for transcription and an LLM for rubric feedback, and you will genuinely practice more because the loop is yours. What you cannot build is the part people actually pay for: a question bank that tracks what is currently showing up in the real exam, and a scoring model calibrated against Pearson's automated marker so the number you see means something. Your DIY grader will be directionally useful and numerically fictional. Good enough for drilling fluency and essay structure, not good enough to decide whether you are ready to book the test.
What can an AI coding agent reproduce from OpenPTE?
A local web app that runs timed PTE-style tasks, records your speaking or captures your typing, transcribes it, and returns rubric feedback plus a trend chart across attempts. Sequence lessons, check understanding, and track progress for one learner. A responsive interface with real empty, loading, success, and error states.
What will a DIY OpenPTE replacement still be missing?
Scores calibrated to the real automated marker, so your numbers are vibes, not predictions; A question bank that is maintained and rotated as the exam changes; Full mock tests with official section timing, weighting and score report layout; Model answers, templates and community discussion around each item; The useful dataset is owned, accumulated, or expensive to reproduce.; Model quality and inference operations are part of the product.
What do I still own after building a OpenPTE alternative?
Secure credentials, rotate secrets, and handle provider rate limits. Run migrations, backups, restores, and dependency updates. Test the critical journey after every model, API, or hosting change. Monitor failures and fix the edge cases a first prompt will miss.