EpiCore

Overview

EpiCore is the backend and processing layer powering EpicTechie, a free and privacy-first platform for everyday document, PDF, image, OCR, and financial workflows. Built with Python and FastAPI, it provides APIs that receive user files, validate requests, execute the required processing workflow, and return generated results to the EpiCanvas frontend. The backend is designed around temporary file processing, so users can complete practical file-based tasks without accounts or permanent storage of their uploaded files.

Problem

File-processing applications require more than a simple upload endpoint. Different tools may require completely different processing pipelines, libraries, validation rules, output formats, and error-handling strategies. EpicTechie needs a backend capable of supporting many independent utilities while maintaining a consistent API experience for the frontend, and it needs to handle potentially sensitive documents responsibly through temporary processing and cleanup.

Solution

EpiCore provides a centralized API and processing layer for EpicTechie's collection of digital tools. Structured APIs let EpiCanvas upload files, validate requests, run document, image, and OCR workflows, return structured results, and offer generated files for download before temporary files are cleaned up. Individual workflows use specialized Python libraries, and the architecture stays extensible so new tools can be added without redesigning the backend.

Architecture

1. 1FastAPI API layer
2. 2Request and file validation
3. 3Tool-specific processing services
4. 4Temporary file workspace
5. 5Document and image processing libraries
6. 6Result generation
7. 7Temporary file cleanup

FastAPI API layer → Request and file validation → Tool-specific processing services → Temporary file workspace → Document and image processing libraries → Result generation → Temporary file cleanup

Responsibilities

• Designed and developed backend APIs using FastAPI.
• Designed the backend architecture for EpicTechie's file-processing tools.
• Implemented file upload and validation workflows.
• Built processing workflows for PDF operations.
• Implemented image processing using Python imaging libraries.
• Integrated OCR processing using Tesseract and pytesseract.
• Generated downloadable output files from processing workflows.
• Implemented temporary file handling and cleanup.
• Designed structured API responses for frontend integration.
• Organized processing logic into reusable tool-specific services.
• Designed the backend to support the addition of new utilities over time.

Challenges

• Supporting multiple file-processing workflows through a consistent API architecture.
• Handling different file formats, input constraints, and output requirements.
• Processing potentially sensitive user documents while minimizing persistent storage.
• Managing temporary files safely throughout the processing lifecycle.
• Providing useful validation and error responses to the frontend.
• Designing reusable backend patterns that make adding new tools straightforward.
• Balancing processing capability with the lightweight and free-first nature of the product.
• Supporting document workflows that may require different processing libraries and techniques.

Tech stack

Screenshots

Impact

EpiCore provides the processing foundation behind EpicTechie's growing collection of digital tools. Its modular architecture allows new PDF, image, OCR, finance, and document workflows to be introduced while maintaining a consistent API boundary between the frontend and backend. Temporary processing also supports the privacy-first product philosophy by avoiding permanent storage of user-uploaded files for core workflows.

Lessons learned

• File-processing systems benefit from clear separation between API handling and processing logic.
• Temporary files require deliberate lifecycle management rather than being treated as ordinary application data.
• A consistent API contract simplifies integration between the processing engine and multiple frontend workflows.
• Tool-specific processing services make a growing collection of utilities easier to maintain.
• Supporting many file formats requires strong validation and predictable error handling.
• Privacy considerations should influence backend architecture from the beginning when processing user documents.

Future improvements

• Expand the processing engine with additional document and image workflows.
• Add more financial document-processing tools.
• Introduce additional OCR capabilities and document intelligence.
• Add asynchronous processing for larger or more resource-intensive operations.
• Improve processing observability and operational monitoring.
• Add automated cleanup safeguards for temporary files.
• Introduce stronger file validation and security controls.
• Expand the API architecture to support future AI-assisted document workflows.
• Optimize processing pipelines for improved performance and resource efficiency.