This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend.
What I Built
Meet Alisha Cetak, a small print shop in Cisontrol, Rancah, Indonesia, owned by my friend A Asep, who agreed to be named in this article.
Like many small businesses, the shop handles practical, everyday work: banners, photo prints, ID cards, invitations, and other printing orders. Prices are maintained on a poster, while order details and transactions have traditionally been recorded by hand.
That workflow works, but recording orders, calculating prices, tracking down payments, and preparing sales summaries can become repetitive.
So I built Asep a small order assistant powered by a locally running Gemma model.
The idea is simple: let the owner describe an order naturally, then let the application turn it into structured, verifiable business data.
For example, Asep can type an order like this:
Pak Dedi pesan spanduk 3x1 dua lembar, DP 100rb
In English, that roughly means:
Mr. Dedi orders two 3 × 1 metre banners, with a 100,000 IDR down payment.
The application extracts the relevant information, matches the item against the shop's price list, calculates the price, and presents a confirmation screen before saving the order.
Once saved, the data can be used to produce receipts in PDF, Excel, or image format for sharing through WhatsApp. The application also provides daily, weekly, and monthly sales reports.
The goal isn't to replace the shop owner with an AI agent. It's to reduce repetitive administrative work while keeping the owner in control of every transaction.
Demo
Demo: CLICK ME!
Screenshots:
I'd also like to include a photo of Asep using the application at his counter, with his permission and with customer information hidden.
The application has been tried at the shop. This is an early, practical use case rather than a claim that the system has already been validated across hundreds of transactions.
Code
Repository: https://github.com/joniilmanfahmi00-collab/alisha-catat
The application is built with Solid-Vue JS, my own Vue + Vite framework with file-based API routes powered by h3.
The rest of the stack includes:
- Ollama + Gemma 3 for local language-model inference.
- SQLite + Drizzle ORM for local data storage.
- Tailwind CSS for styling.
- Tabler Icons for interface icons.
- Chartist for sales charts.
- pdf-lib for PDF receipts.
- ExcelJS for Excel exports.
- Decimal.js for monetary calculations.
How I Built It
1. A local model running on modest hardware
I used gemma3:4b through Ollama on my development machine:
- AMD A8-9600 CPU
- 8 GB RAM
- No dedicated GPU
This was an important constraint. I wanted to explore whether an open-weight model could be useful for an actual small-business workflow without requiring a GPU, a cloud inference service, or a subscription to a hosted language-model API.
The model runs locally on the machine. For typed orders, the core order-parsing workflow does not require an internet connection.
The performance is not instant, but the experiment showed that a small local model can still be useful when the task is narrowly defined.
2. Gemma extracts data; ordinary code handles the money
One of the most important design decisions was limiting what the model is allowed to do.
Gemma is responsible for extracting structured information from the customer's natural-language order, including:
- Customer name
- Product or service
- Dimensions or size
- Quantity
- Unit
The model returns JSON constrained by a schema.
For example, an order mentioning two banners measuring 3 × 1 metres should be represented as structured fields rather than left as an unstructured sentence.
The application then takes over.
Gemma does not decide the price, calculate the total, or determine the amount of money received.
Those operations are handled by deterministic application code:
- The extracted product is matched against the shop's price list.
- The price is calculated according to the applicable pricing rule.
- The down-payment amount is parsed separately.
- Monetary calculations use Decimal.js.
- The resulting order is shown in a confirmation card.
- The user can correct the extracted information before saving it.
The price list supports different pricing methods, such as per-unit prices, per-square-metre prices, per-pack prices, and manually entered price ranges where necessary.
This separation matters because a language model can misinterpret an order. It should not be trusted to invent a price or perform financial calculations without deterministic checks.
The model helps interpret the customer's words; the application remains responsible for the transaction.
3. A confirmation step instead of blind automation
I deliberately included a confirmation card rather than saving every model response immediately.
An incorrectly interpreted dimension, quantity, or customer name can create problems at a real print shop. Even a small mistake can affect the price or the final product.
The confirmation step gives Asep a chance to review and correct the extracted information before the order is stored.
If the model is unavailable or too slow, the same interface can be used as a manual form.
This fallback is important: the business workflow should not become unusable simply because an AI component is unavailable.
AI is an assistant in this application, not a mandatory dependency for every action.
4. From an order to a useful business record
After confirmation, the application stores the order locally in SQLite.
That record can then be used to generate receipts and sales summaries. Instead of treating each transaction as an isolated piece of handwritten information, the application makes the data available for daily, weekly, and monthly reporting.
The workflow is therefore more than a text-to-JSON demonstration.
It connects language-model inference to a practical business process: order entry, validation, pricing, record keeping, receipt generation, and reporting.
What I Measured
I ran a small experiment on the CPU-only development machine using five invented sample orders. These were test inputs, not a representative dataset from the shop, so the results should be treated as an initial observation rather than a rigorous benchmark.
| Configuration | Correct extractions | Approx. time per order |
|---|---|---|
| Gemma 3 4B, longer prompt | 5/5 | 37 seconds |
| Gemma 3 4B, shorter prompt | 5/5 | 23 seconds |
| Gemma 3 1B, shorter prompt | 4/5 | 11 seconds |
For the 1B model, the missed extraction was flagged by a warning in the application.
Two lessons stood out.
First, prompt length matters on limited hardware. In this small test, shortening the prompt reduced the time per order from around 37 seconds to around 23 seconds. That is approximately a 38% reduction.
The result suggests that keeping the task focused and avoiding unnecessary prompt instructions can make local inference more practical. It does not establish that prompt processing alone accounted for the entire difference; these timings include the model's overall response time.
Second, a smaller model can be useful when paired with appropriate application-level validation. The 1B model was faster but made one mistake in five samples. The warning helped surface that problem rather than silently treating every output as correct.
These results are not enough to conclude that the smaller model is generally better or that the larger model will always be accurate. They simply helped me understand the trade-offs on my available hardware.
For a real deployment, I would want a larger and more varied test set, repeated timing measurements, and evaluation against actual orders with permission from the shop owner.
Already Used in the Shop
Asep has been trying the application at his counter. He shared the following feedback over WhatsApp and gave me permission to quote it:
intinamah mantap, aplikasina ringan, mudah di akses bisa offline oge. jeng mempermudah rekap harian sampai bulanan toko saya
In English, the message means approximately:
Overall, it's great. The application is lightweight, easy to access, works offline too, and makes it easier to recap my shop's sales from daily to monthly.
For me, this feedback matters more than simply demonstrating that a model can generate valid JSON.
The application was built for a particular person with a particular workflow, and he has started using it to see whether it helps with his work.
There is an important qualification to the offline claim, though.
Asep's shop PC does not have a microphone, so voice input is not part of his current daily workflow. He has mainly been using the typed-order flow.
The application can still be useful without voice input: he can enter an order, review the extracted data, confirm the transaction, and use the resulting records for reporting.
The same application could potentially support other small shops by letting them configure their own price lists and product types, although each shop's workflow and pricing rules would need to be checked.
Why Open Innovation Matters
For this project, open-weight AI and local inference were not just technical preferences. They made the approach practical for the environment in which the application was built.
1. No per-request cloud inference fees
A small print shop may not have enough order volume to justify a recurring AI service subscription.
Running Gemma locally avoids per-request fees for the model inference itself. There are still costs associated with the computer, electricity, maintenance, and software development, but the shop does not need to pay a hosted-model provider for every order parsed.
That makes the operating cost easier to predict.
2. Order data can stay on the shop's computer
For typed orders, the text is sent to the locally running model rather than a remote LLM API.
This reduces the need to transmit customer names and order details to an external inference provider.
Local processing does not automatically guarantee complete privacy or security. The computer, application, database, backups, and any other connected services still need appropriate protection. But keeping inference local gives the business more control over where its data is processed.
3. It can run without a dedicated GPU
The experiment used an AMD A8-9600 CPU and 8 GB of RAM, without a dedicated GPU.
The response time is a clear limitation, but the setup demonstrates that a local model can be explored on modest hardware.
Not every small business needs a powerful AI workstation. Sometimes a practical, slower solution is more accessible than a faster solution that requires new hardware or recurring service fees.
4. I can change the model and its behaviour
Using an open-weight model with Ollama lets me experiment with different model sizes, prompts, and structured-output approaches.
That flexibility made it possible to compare Gemma 3 4B and 1B on the same small set of sample orders and to adjust the prompt without being tied to one hosted API.
A closed API could also provide structured extraction, and I am not claiming that local inference is always more accurate or faster. The advantage here is having more control over the model deployment and the ability to run the core parsing workflow locally.
For this particular use case, those trade-offs are worth exploring.
Honest Limitations
The application is an early project, and there are several limitations worth making explicit.
- Local inference is relatively slow. On my development machine, the tested configurations took approximately 11–37 seconds per order. Actual performance will depend on the hardware, model, prompt, and input.
- The benchmark is very small. Five invented orders cannot establish production-level accuracy or reliability.
- Human confirmation remains necessary. The extracted order must be reviewed before saving, especially when dimensions, quantities, or customer details affect the transaction.
- Voice input is not guaranteed to work offline. It uses the browser's speech-recognition capability, which may rely on a remote service depending on the browser and implementation. Gemma processes the resulting text locally, but that does not mean the audio itself is processed locally.
- The shop PC has no microphone. Consequently, voice input has not been part of Asep's daily usage.
- Microphone access has browser restrictions. Browsers generally require a secure context, such as HTTPS or localhost, for microphone access. A phone opening the application over a plain HTTP LAN address may not be able to use the microphone. Keyboard dictation is an alternative, depending on the device.
- Local does not mean maintenance-free. The application still needs backups, sensible access controls, error handling, and a plan for updates and data recovery.
I would like to improve the voice workflow and test the application against more varied orders. I would also like to collect feedback over a longer period before making stronger claims about how much time it saves.
What I Learned
This project reinforced a principle I keep coming back to: AI is most useful when it is given a clear responsibility inside a well-defined workflow.
Gemma does not need to understand the entire business. It needs to extract a small set of fields from a customer's order.
The application does not need to trust the model with financial decisions. It can validate the extracted data, apply explicit pricing rules, and ask the owner to confirm the result.
And the shop does not need a complex cloud-based architecture just to organise its orders and produce sales reports.
The technical challenge was not simply getting a model to respond. It was integrating the model into a workflow that remains understandable, controllable, and useful when the model makes a mistake or is unavailable.
That is also why I enjoyed building this for Asep. It connects software development with a real business problem rather than adding AI to an application just because AI is fashionable.
Prize Categories
I am submitting this project for consideration in the Best Use of Gemma category because Gemma 3 is the core model used to interpret natural-language orders.
The model is not a decorative chatbot attached to an otherwise unrelated application. Its structured extraction is what connects free-form order descriptions to the application's validation and pricing workflow.
Final Thoughts
Alisha Cetak started with a straightforward problem: order details were written by hand, prices were kept separately, and preparing sales recaps required additional work.
The result is a small, local-first order assistant that connects natural-language input to structured records, deterministic pricing, receipts, and sales reports.
It is not a perfect system, and I am not presenting five test orders as proof of production reliability. The model is slow on low-end hardware, voice input has limitations, and the application still needs more real-world evaluation.
But it has reached the point where its intended user can try it in his own shop and tell me whether it helps.
For me, that is the value of building for a friend: starting with a problem that matters to someone, choosing technology that fits the constraints, and being honest about what works and what still needs improvement.
Open innovation made it possible to experiment with a locally running model, avoid per-request inference fees, and keep typed order parsing on the shop's own computer.
Sometimes a useful AI project does not need to be a large autonomous agent. It can be a small, carefully scoped component that makes an ordinary business task a little easier.
Thanks for reading! I'd love to hear how you'd approach reliable local order extraction or genuinely offline voice input for a small business.
Top comments (2)
thank's boy
Your'e Wellcome