Overview
A small application built for one important outcome
Quiz was a quick, purpose-built study application for my wife while she prepared for her board exams. It turned notes and school materials into focused test banks that could be reviewed through a simple card-based interface.
AI played a large role in accelerating the build and helping transform source material into application content. The project stayed intentionally small: its job was to support studying, not become another general-purpose learning platform.
Problem
Make dense study material easier to practice
Notes and school materials contain the information needed for an exam, but reading them repeatedly does not create the same feedback loop as answering a question and checking the result.
The application needed to turn that material into short practice sessions without adding account management, content administration, or infrastructure that would delay its actual use.
Constraints
Optimize for speed, accuracy, and a narrow audience
Short build window
Deliver something useful quickly enough to support active board-exam preparation.
Content correctness
Questions and answers needed to stay faithful to the source material across every test bank.
No operational data
The product did not need shared accounts, user-generated content, or frequently changing server-side records.
Comfortable study sessions
The interface needed to remain readable across devices and different lighting conditions.
Minimal runtime surface
Avoid adding authentication, a database, or backend state that the single-user study workflow did not require.
Repeatable deployment
Use the same established container pipeline as the other projects while keeping the application itself small.
Architecture
Static question banks with a small deployment footprint
Unlike Nades and Meals, Quiz did not need PocketBase or another database. Test banks live in JSON files that are versioned and deployed with the Next.js application, removing an entire persistence layer from the runtime system.
The application also has no authentication. Docker and GitLab still provide a repeatable production artifact and deployment path, while Nginx and Certbot handle public traffic and certificates outside the application container.
01
Study material
Notes and course content provide the source for questions and answers.
02
JSON test banks
Structured files keep the quiz content simple, portable, and version-controlled.
03
Next.js and React
Card-based study sessions present questions, answers, navigation, and light or dark themes.
04
Self-hosted delivery
GitLab packages and deploys the container behind Nginx and independently managed TLS.
Technical decisions
Use the simplest architecture that fit the actual product
JSON instead of a database
Keep test-bank data close to the code because it changed through development rather than through application users.
Quizlet-style cards
Use a familiar question-and-answer interaction that keeps attention on one prompt at a time.
Light and dark themes
Explore Tailwind's theme patterns while making longer study sessions comfortable in different environments.
Keep the scope personal
Avoid accounts, administration, and generalized learning features that did not help the immediate user.
Version content with code
Make every test-bank change inspectable and deployable through the same review path as application behavior.
Reuse proven infrastructure
Deploy through the existing Docker and GitLab workflow without allowing shared infrastructure to expand the product scope.
Implementation
Content became part of the application build
Material extraction
Transform notes and school resources into consistent prompts and answers organized into separate test banks.
File-backed content
Load structured JSON directly with the application so question sets remain portable, reviewable, and predictable at runtime.
Focused card flow
Present one question at a time through a familiar reveal-and-review interaction that supports short practice sessions.
Theme system
Use Tailwind's light and dark variants as a contained way to learn theming and improve comfort in different environments.
Challenges
Generating questions was easier than trusting them
Extracting source material
Notes and school materials first had to be transformed into consistent, structured questions suitable for the application.
Validating AI-assisted content
Every generated question and answer needed review against the source; plausible wording was not enough for board-exam preparation.
Consistency across test banks
As the content set grew, formatting and answer quality needed to remain uniform between separate JSON files.
Keeping the build intentionally small
The familiar temptation to add accounts or content-management features had to be weighed against the application's immediate purpose.
Results
A lightweight tool that served its intended user
Focused study sessions
The finished application turned course material into a simple question-card workflow for board-exam preparation.
Small runtime
Removing the database kept the deployment and operational surface compact.
Practical Tailwind experience
The build provided hands-on practice with responsive styling and light/dark theme behavior.
A useful quick build
The project did not need to be novel or broad to be worthwhile; it solved a specific problem for someone who mattered.
Lessons learned
Correctness belonged to the content pipeline
The main risk was not application scale—it was confidently presenting an incorrect answer. AI could accelerate extraction and drafting, but subject-matter verification remained essential.
Quiz also reinforced that omitting infrastructure is an engineering decision. JSON was not a shortcut around a missing database; for fixed, versioned test banks, it was the more direct fit.
What's next
Stay small unless the requirements change
If the content is revisited, the highest-value improvement would be stronger schema and source validation for the JSON test banks. A database or account system should only enter the design if the application gains new users or user-managed content.