CipherQ: What If Your AI Assistant Could Work Without Sending Your Private Documents to Someone Else's Cloud?

I’m building CipherQ, a private AI workspace that combines encrypted file storage, document retrieval, and local AI assistance on hardware you control. My starting point is the Arduino UNO Q: a compact computing platform for exploring a different approach to personal AI infrastructure.

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

CipherQ is an open-source private AI workspace designed for people who want AI-assisted document workflows without making a third-party cloud service the centre of their infrastructure.

Imagine you're a freelancer handling client contracts, a student managing research papers, a consultant organizing project files, or a small business owner dealing with invoices and internal records.

You want to ask questions about your documents, find information quickly, and keep your files organized. But many hosted AI services require you to send document contents to an external provider, pay recurring fees, or depend on someone else's infrastructure.

I wanted to explore a different approach.

What if your AI workspace could run on hardware you own, with your files and AI processing kept under your control?

That question became CipherQ.

The product

CipherQ brings together five parts of a private workspace:

• Private file storage: A place to store and manage personal or business documents.
• Encryption: A security layer intended to protect stored files and sensitive information.
• AI-assisted document workflows: A planned workflow for asking questions about documents using local Gemma inference.
• Document retrieval: A way to locate relevant information in a user's files and use it as context for AI responses.
• Account and access management: Authentication and account/plan features for a workspace intended to support multiple users.

The project separates its public web interface from the machine responsible for private computation and storage.

Why Arduino UNO Q?

I chose the Arduino UNO Q because I wanted to explore whether a compact, affordable computing device could serve as the starting point for a self-managed AI workspace.

Instead of assuming that every user needs a cloud server, I am exploring an architecture in which the device handles the backend, local storage operations, and AI workloads that its available resources can support.

The concept also allows for future storage expansion. Compatible external USB storage devices and SSDs could extend the available capacity beyond the device's built-in storage, subject to hardware compatibility, power requirements, filesystem support, and software configuration.

The aim is to let users start small and add storage as their needs grow.

Who would pay for it?

CipherQ is intended for people who handle documents regularly and value control over their data.

• Freelancers: Keep client documents organized and retrieve information from project files.
• Students and researchers: Search notes, papers, and study materials.
• Consultants: Work with proposals, reports, and reference documents.
• Small businesses: Manage invoices, internal documents, and operational records.
• Privacy-conscious individuals: Experiment with personal AI without making a hosted AI service their default workspace.

The problem is not that cloud AI has no value. It is that some users want more control over where their information is stored, where inference takes place, and how much they spend on recurring services.

CipherQ explores that alternative.

The business opportunity

The business model is based on affordable subscriptions, optional hardware setup assistance, and paid support.

These are proposed prices for testing with potential users. They are not active subscriptions, validated prices, or evidence of established customer demand. Online payment processing has not been integrated yet.

There are three potential revenue streams:

1. Subscriptions: Charge for larger storage allowances and additional workspace features.
2. Setup assistance: Help users configure their own compatible hardware, storage, and secure access.
3. Support and maintenance: Offer paid installation assistance, troubleshooting, and ongoing technical support.

The business model must account for hardware, electricity, storage, backups, security updates, maintenance, and customer support. Local inference may reduce external model API charges, but it does not make operating costs disappear.

My aim is to test whether a small, focused product can offer enough value to justify an affordable recurring fee.

Demo

Live frontend: Open CipherQ

Video demonstration: Watch CipherQ on YouTube

The web interface is published through GitHub Pages. The backend runs separately on the Arduino UNO Q.

The complete remote workflow requires a reachable HTTPS API endpoint, appropriate cross-origin configuration, session handling, and a secured connection between the public frontend and the private device.

I am still validating that end-to-end path. The published frontend should not be interpreted as proof that remote authentication, encrypted file operations, and local AI document question-answering are all production-ready.

My next demonstration milestone is to record a real workflow on the hardware: connect to the application, authenticate, select a document, retrieve relevant content, and generate an answer using the intended local AI engine.

That demonstration will matter more than a polished interface alone because it will establish what works on the actual device.

Code

GitHub repository: nimalan-parameswaran/CipherQ

The repository is the place to inspect the source code, follow the project's progress, and contribute.

The project is organized around a static frontend and a separate backend service. This separation allows the interface to be distributed independently of the machine holding the files and running the backend.

I want the repository to be useful to developers who are interested in:

• Local AI inference on compact hardware.
• Private document retrieval and AI-assisted workflows.
• Encrypted file storage and access-control design.
• Self-hosted services with public web interfaces.
• Extending storage on small computing devices.
• Building affordable, open-source tools for freelancers and small businesses.

CipherQ is under active development. I welcome feedback, bug reports, and contributions, particularly around deployment, storage handling, authentication, and security testing.

If you encounter an issue or have an idea for a feature, please open an issue in the repository. I am actively working on the project and will follow the discussions there.

How I Built It

CipherQ is designed around a simple architectural principle: keep the interface accessible while allowing private computation and storage to remain under the user's control.

1. A public web interface

The frontend is hosted on GitHub Pages.

A static frontend is relatively inexpensive to host and easy to distribute. It also means the user interface does not need to run on the same machine as the backend.

However, GitHub Pages only hosts the frontend. It does not automatically expose the Arduino UNO Q or make its private API accessible from the internet.

2. FastAPI on Arduino UNO Q

FastAPI is the backend layer responsible for handling application requests.

The frontend uses a configurable API base URL, allowing the backend address to be changed without tying the application to a single deployment environment.

For remote access, the backend needs an appropriately secured network path, HTTPS, correct CORS settings, and reliable authentication and session handling.

I am treating these as engineering requirements rather than assuming that publishing the frontend makes the entire application remotely accessible.

3. Gemma and local AI

Gemma is the intended local AI engine for document assistance.

The intended workflow is straightforward:

1. A user selects or uploads a document.
2. The backend processes the file and retrieves relevant text.
3. Relevant content is passed to the local model as context.
4. The model generates an answer based on the retrieved material.
5. The application returns the answer to the user.

This approach is commonly associated with retrieval-augmented generation (RAG). It can make document assistance more useful because the model receives relevant information instead of relying entirely on its training data.

Local inference also creates an opportunity to reduce the need to send prompts and document contents to an external model API.

Actual performance will depend on the model variant, quantization, memory requirements, document-processing pipeline, and available compute resources on the Arduino UNO Q. The intended workflow still needs end-to-end validation on the target hardware.

4. Encryption, authentication, and document retrieval

A private AI workspace needs more than a local model.

CipherQ brings together file-management workflows, authentication, encryption, and document retrieval. Each part has its own security requirements.

For example:

• Authentication must identify the user correctly.
• Authorization must prevent users from accessing other users' files.
• Encryption must protect data at rest and use appropriate transport security for network connections.
• Key management must protect encryption keys rather than storing them alongside protected files without safeguards.
• Document retrieval must respect file permissions.
• Logs and error messages must avoid exposing sensitive document contents or credentials.

These are requirements for a trustworthy product, not claims that every security property has already been independently verified.

Before production use, the relevant endpoints, key-handling paths, file operations, session flows, and network configuration must be tested.

5. Plug-and-play storage expansion

CipherQ is intended to support compatible external USB drives and SSDs so users can expand their available storage as their document collections grow.

The intended benefit is straightforward: users should not have to depend entirely on the device's built-in storage when their needs increase.

External storage could offer several practical benefits:

• Add capacity without replacing the main device.
• Keep larger document collections on removable storage.
• Choose storage capacity based on individual requirements and budget.
• Expand a small initial setup as more users or files are added.

Actual plug-and-play behaviour depends on supported filesystems, USB connectivity, power requirements, mounting permissions, and application-level storage handling. External drives must also be included in the encryption, access-control, backup, and recovery design.

This is a planned capability that needs hardware and software validation before it can be advertised as a fully supported feature.

6. Turning the project into a side hustle

A technically interesting project is not automatically a viable business.

For CipherQ to become a sustainable side hustle, it must solve a problem that users experience often enough to justify paying for it.

I would start with a small group of freelancers, students, and small businesses. I would ask them to test document organization, retrieval, and AI assistance, then measure which workflows save time and which features they would pay for.

I would also need to measure actual device performance, storage costs, support requirements, and the cost of maintaining secure remote access.

The proposed ₹100 and ₹150 monthly plans are starting hypotheses. User feedback, operating costs, and real usage should determine whether those prices are sustainable.

The goal is to create a focused product that users can understand, test, and trust, rather than trying to compete with every general-purpose AI platform.

Why Does Open Innovation Matter?

Open innovation matters to CipherQ because the product is intended to give users more control over both their information and the tools used to process it.

1. Less dependence on closed AI APIs

A hosted AI API can be convenient, but it also creates dependence on external pricing, service availability, usage limits, and data-handling policies.

Using an open-weight model such as Gemma gives developers the option to experiment with local inference, subject to the model's licence and hardware requirements.

The long-term goal is to make the AI engine replaceable, so the project can test different compatible models without redesigning the entire application.

2. More control over private information

Local inference can reduce the need to transmit document contents to an external model provider.

However, local execution alone does not guarantee privacy. The application must still protect files, credentials, encryption keys, logs, network connections, and user sessions.

Open source gives other developers the opportunity to inspect those mechanisms and identify weaknesses.

3. Affordable hardware experimentation

The Arduino UNO Q gives me a physical platform for exploring a self-managed AI workspace.

It encourages practical questions about memory usage, model size, response time, power consumption, and storage limits. These measurements matter when a product is intended for users who cannot afford a dedicated server or cloud GPU.

The project also explores external storage as a way to extend the device's capacity without requiring users to move immediately to more expensive hardware.

4. A business that is not tied to one provider

If document processing can run locally, some recurring model API charges may be avoided.

That can help the business model, although local hardware has its own costs, and not every model or workload will perform well on a small device.

Open technology gives the project more freedom to measure those trade-offs and choose an approach based on real requirements.

5. A repository other people can learn from

An open repository makes it possible for other developers to inspect the architecture, reproduce problems, suggest security fixes, test hardware compatibility, and contribute features.

For a project like CipherQ, community review is especially valuable because security and privacy claims should be supported by implementation details and tests, not marketing language.

I want the project to help other builders explore local AI and self-hosted tools, even if they eventually adapt the code for a different device or use case.

The goal is not to claim that local AI solves every privacy problem. It is to make another approach possible, inspectable, and accessible to people building on a small budget.

My Agent Session

I am focusing on making the implementation and hardware testing reproducible. A public DevRelay agent-session link is not included in this submission yet.

I plan to add a shareable session when one is available, so readers can inspect the development process rather than seeing only the finished presentation.

Prize Categories

The categories below are relevant only where the project meaningfully uses the partner technology. I would enter:

• Best Use of Arduino: Arduino UNO Q is the target hardware for CipherQ's self-hosted backend and planned local workspace.
• Best Use of Gemma: Applicable when the local Gemma inference workflow is actually demonstrated as part of the project.

I would not claim other partner categories without implementing and documenting their technology in CipherQ.

What Comes Next

My next milestones are focused on making the project work reliably:

1. Validate login and session handling from the public frontend.
2. Complete and test the secure connection between the frontend and the local backend.
3. Test encrypted storage, file permissions, and document retrieval.
4. Run the intended Gemma workflow on the Arduino UNO Q and measure response time and resource usage.
5. Test compatible external storage, including mounting, file operations, and recovery after disconnection.
6. Invite early users to try real document workflows and collect their feedback.
7. Validate the pricing model against real user demand and operating costs.

I would rather demonstrate one complete, reliable document-to-answer workflow than claim a long list of features that have not been tested.

A Question for the Community

If you could run a private AI assistant on hardware you control, what would you use it for first?

• Client contracts and project documents?
• Research papers and study notes?
• Invoices and small-business records?
• Personal knowledge management?
• A completely different use case?

I would also appreciate feedback from developers who have deployed local models, worked with the Arduino UNO Q, implemented encrypted storage, or turned open-source software into a sustainable small business.

If you spot an issue or have an idea for a feature, please open an issue in the CipherQ repository. I am actively working on the project and welcome constructive feedback.

CipherQ is an exploration of a simple idea: people should have the option to use AI while keeping more control over their own files, hardware, and costs.

The goal isn't to replace every cloud AI service. It's to give people another choice.

devchallenge #hf26challenge #OpenSource #AI #Gemma #Arduino