This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle
What I Built
RedactIt is an AI-assisted document redaction tool designed to make removing sensitive information from documents more intuitive.
Redacting a document sounds simple until you have to identify exactly what should be removed without accidentally hiding information that needs to stay. Manually reviewing documents can be tedious, and overly broad automated redaction can remove important context.
I wanted to explore a different approach: what if you could describe what you want to redact in plain English, review the suggested matches, and stay in control of the final result?
That's the idea behind RedactIt.
The intended workflow is straightforward:
Provide a supported document, such as a PDF or DOCX.
Describe what should be redacted using natural-language instructions.
Let the AI-assisted pipeline interpret the instruction and identify potential matches.
Review the proposed redactions before approving or rejecting them.
Generate the redacted document through the existing processing pipeline.
RedactIt is being built around human review rather than blindly trusting an AI-generated result.
Who could use it?
Potential users include freelancers handling client documents, small teams processing business paperwork, researchers working with sensitive information, and professionals who need to prepare documents for sharing.
These users may value a tool that reduces repetitive review work while keeping them involved in decisions about what gets removed.
For a potential side hustle, I'm interested in exploring a practical model: a useful free or self-hostable tool, with paid options for teams that need a smoother workflow, integrations, or additional document-processing capabilities. That's a possible direction, not an established busness model or paying-customer claim.
Demo
https://redact-it-1.onrender.com
Code
GitHub repository: https://github.com/ivy1o1/Redact-It
The project focuses on the pipeline behind instruction-based redaction, rather than simply wrapping a chatbot around a file upload.
How I Built It
The central technical challenge was figuring out how to combine natural-language understanding with predictable document-processing behavior.
RedactIt uses a backend-driven pipeline with a configured Gemma model integration, candidate matching, evaluation, and validation.
At a high level, the workflow looks like this:
Document + Redaction Instruction
|
v
Backend Processing
|
v
Instruction Interpretation
(Gemma integration)
|
v
Candidate Matching
|
v
Evaluate Proposed Matches
|
v
Human Review
|
v
Apply Redactions
|
v
Verify the Output
The exact verification and processing capabilities depend on the supported document type and the existing pipeline.
One important design decision was to avoid letting the language model independently decide to redact arbitrary content without constraints. Candidate matching and evaluation help connect proposed redactions to evidence from the document, while human review provides an opportunity to catch mistakes before finalizing the result.
This is especially important for redaction: removing too little can expose information, but removing too much can make a document useless.
I also built and tested the backend workflow, including model integration tests. The next priority is making the frontend experience feel as seamless as the underlying workflow: clear instructions, understandable results, and explicit control over proposed redactions.
Why Does Open Innovation Matter?
For a project like RedactIt, open innovation matters because document processing can involve information people would rather not send to an external AI provider.
Using an open-weight model such as Gemma gives developers more control over model selection, deployment architecture, and how inference fits into an application.
It also makes experimentation possible. Instead of treating an AI API as a black box, I can investigate how model output interacts with candidate matching, validation, and the rest of the processing pipeline.
There are trade-offs, of course. Running a model requires suitable infrastructure, and an open-weight model does not automatically make an application private, secure, or accurate. Those properties depend on the complete system, including where documents are processed, how data is handled, and how results are validated.
For me, the interesting part is being able to build and inspect the entire workflow instead of relying on a single closed API call.
My Agent Session
Optional: I'll add a DevRelay agent session here if I have a saved session that demonstrates the development process.
Prize Categories
I'll select the partner categories that match the actual technologies and tools used in this submission.
RedactIt is an ongoing project, and the goal is to make document redaction more approachable without hiding the decisions that matter.
The principle I'm building around is simple: let AI help identify what should be removed, but keep people in control of what actually gets redacted.
I'd love feedback on the approach, especially from anyone who has worked on document processing, privacy tooling, or human-in-the-loop AI systems.
Top comments (0)