PrintGo

Digital print ordering for faster requests, clearer production, and smoother pickup.

PrintGo is a modern online printing platform built for students, campus organizations, and small print shops that want faster ordering, clearer handoffs, and less back-and-forth.

Instead of handling print requests through chat messages, paper forms, and manual follow-ups, PrintGo gives customers a simple digital flow for uploading files, choosing print settings, submitting payment proof, and tracking order progress from request to pickup.

At A Glance

• turns manual print requests into a structured digital workflow
• supports both customer ordering and admin-side fulfillment operations
• designed for real print-shop friction, not just generic storefront browsing
• built as a practical service-business product with room to scale

Why This Project Stands Out

PrintGo is more than a file-upload form. It handles the operational details that make print ordering actually usable in practice: file validation, page counting, layout options, payment proof, order tracking, and admin-side queue management.

That makes the repo attractive for:

• campus entrepreneurs or print shops looking for a digital ordering workflow
• recruiters evaluating practical full-stack execution and operational UX
• collaborators who want a product with obvious real-world use and room to scale

The Pitch

PrintGo helps print businesses look more professional and operate more efficiently.

Customers get:

• a cleaner ordering experience
• clearer print options per file
• easier payment-proof submission
• order tracking without needing constant follow-up

Operators get:

• a more organized print queue
• fewer manual clarifications
• better visibility into order status
• a workflow that can scale beyond casual chat-based ordering

Demo Flow

The product story is easy to understand in one quick walkthrough:

1. A customer uploads a file and chooses print settings.
2. The customer selects page ranges, layout options, and order details.
3. Payment proof is submitted inside the same workflow.
4. Staff review the request in the admin queue and move it through fulfillment.
5. The customer tracks progress until the order is ready for pickup.

That flow makes PrintGo feel like a real operations product, not just a landing page with a form attached.

Screenshots

Customer Experience

Admin Experience

Problem

Traditional print ordering is messy.

• customers send incomplete instructions through chat
• operators have to clarify paper size, page range, copies, and layout manually
• payment verification slows down fulfillment
• order updates depend on someone replying at the right time
• growing order volume quickly turns into queue confusion

For student-heavy printing environments, that friction adds up fast.

Solution

PrintGo turns that manual process into a structured ordering workflow.

• customers upload files and configure print options per document
• the system supports page-range selection and pages-per-sheet layouts
• payment proof can be attached directly to the order
• customers can track progress without repeated follow-up messages
• admins get a cleaner queue, order history, and workflow visibility

The result is a smoother experience on both sides of the counter.

Repository Standards

• License: LICENSE
• Security policy: SECURITY.md
• Contribution guide: CONTRIBUTING.md

Core Experience

• guest and account-based ordering
• PDF and Office file uploads
• per-file print settings
• page-range selection
• 1-up, 2-up, and 4-up printing
• GCash payment proof upload
• order tracking
• admin dashboard, queue, history, and logs

Product Highlights

• structured ordering that reduces incomplete or confusing requests
• operational support for both PDF and Office-based print jobs
• built-in payment-proof handling for smoother confirmation
• status visibility for customers and queue visibility for operators
• strong base for future notifications, pricing rules, and multi-branch workflows

Built For

• student-focused print services
• school and campus printing operations
• small print shops that want a digital order pipeline
• founders validating a practical service-business product

Business Value

• improves customer experience with a more polished ordering journey
• reduces repeated clarification work for shop staff
• creates a more reliable handoff between payment, production, and pickup
• makes small print operations feel more credible and scalable
• turns a manual service into a productized workflow

How It Works

1. A customer uploads a file and selects print preferences.
2. The platform captures the order details needed for production.
3. The customer submits payment proof.
4. Staff review and process the job through the admin workflow.
5. The customer tracks progress until the order is ready for pickup.

Why It Wins

• built around real print-shop friction, not just generic ecommerce patterns
• handles operational edge cases like file type support and page counting
• useful for both guest users and returning account-based customers
• practical admin workflow instead of a customer-only frontend
• strong foundation for future expansion into pricing automation, notifications, and branch operations

Portfolio Value

PrintGo is a strong portfolio piece because it shows:

• product thinking around a real-world operational problem
• full-stack implementation across frontend, backend, storage, and file handling
• workflow design for both customer-facing and admin-facing users
• practical business framing instead of a purely technical demo

Contributors

This project is developed with support from Claude and Codex for implementation, iteration, debugging, and QA workflows.

See CREDITS.md for project credit details.

Stack

• Node.js
• Express
• Supabase Postgres
• Supabase Storage
• Vanilla HTML, CSS, and JS
• LibreOffice for Office file page counting (docx, xlsx, pptx)

Project Structure

• client
• server
• server/db
• directives
• scripts

Developer Notes

The sections below focus on local setup and implementation details for contributors and evaluators who want to run the project.

Local Setup

1. Requirements

Install:

• Node.js 22+
• npm
• Supabase project
• LibreOffice

LibreOffice is needed if you want automatic page counting for:

• .docx
• .xlsx
• .pptx

Without LibreOffice:

• PDF counting still works
• Office files fall back to manual page count

2. Install Dependencies

npm install

3. Configure Environment

Copy:

copy .env.example .env

Then fill in real values in .env:

• SUPABASE_URL
• SUPABASE_SERVICE_KEY
• APP_AUTH_SECRET
• SUPABASE_STORAGE_BUCKET
• BINDING_FEE
• RUSH_FEE
• GCASH_ACCOUNT_NAME
• GCASH_ACCOUNT_NUMBER
• GCASH_QR_URL

If LibreOffice is installed locally, also set:

LIBREOFFICE_PATH=C:\Program Files\LibreOffice\program\soffice.exe

4. Set Up Supabase

In Supabase:

• create your project
• create the storage bucket printgo-files
• run the required SQL migrations in Supabase SQL Editor

Recommended migration order:

• server/db/schema.sql
• server/db/username_auth_migration.sql
• server/db/order_items_migration.sql
• server/db/pickup_confirmation_migration.sql
• server/db/page_selection_and_a3_migration.sql
• server/db/pages_per_sheet_migration.sql

If you are working from an older database, also review:

• directives/supabase-setup-checklist.md

5. Run Locally

Development:

npm run dev

Production-style local run:

npm start

Default local URL:

http://localhost:3000

6. Local Smoke Test

Check these:

• /
• /order
• /tracking
• /login
• /register
• /admin
• /admin/orders

Then test:

• create an order
• upload a payment proof
• track the order
• review it in admin
• move it through completion

Render Deployment

This repo already includes:

• render.yaml
• Dockerfile

1. Push To GitHub

Push the repo to your GitHub remote.

2. Create a Render Blueprint

In Render:

1. choose New
2. choose Blueprint
3. select this repo
4. keep:
   • branch: main
   • blueprint path: render.yaml

3. Set Render Environment Variables

Set these in Render:

• SUPABASE_URL
• SUPABASE_ANON_KEY
• SUPABASE_SERVICE_KEY
• APP_AUTH_SECRET
• GCASH_ACCOUNT_NAME
• GCASH_ACCOUNT_NUMBER
• GCASH_QR_URL

Already handled by render.yaml:

• PORT=10000
• SUPABASE_STORAGE_BUCKET=printgo-files
• BINDING_FEE=15
• RUSH_FEE=10
• LIBREOFFICE_PATH=/usr/bin/libreoffice

4. Deploy

Apply the Blueprint and wait for the service to build.

Health check path:

/order

5. Verify Deployment

Open the live app and test:

• homepage
• order flow
• tracking
• admin dashboard
• admin queue
• proof/file preview and download

Important:

• Render free may sleep when idle
• first load can be slow

VPS Deployment

If you want a more reliable production setup, use a VPS.

This repo includes:

• scripts/deploy-ubuntu.sh
• .env.production.example

1. Prepare the Server

Copy the project to your Ubuntu server.

Copy:

cp .env.production.example .env

Then fill in real values.

2. Run the Deploy Script

chmod +x scripts/deploy-ubuntu.sh
./scripts/deploy-ubuntu.sh

Optional Nginx setup:

DOMAIN_NAME=yourdomain.com RUN_NGINX_SETUP=true ./scripts/deploy-ubuntu.sh

3. Run Migrations

Run the same SQL migrations in your production Supabase project before going live.

Important Notes

Office File Counting

Automatic page counting for Office files depends on LibreOffice.

If it is missing:

• the app still runs
• PDF counting still works
• Office files may need manual page count

Uploaded Files

Uploaded files are stored in Supabase Storage, not permanently on local disk.

The app uses temporary local upload processing, then pushes files into the storage bucket.

Admin Routes

• /admin = dashboard
• /admin/orders = order queue

Release Checklist

Before demo or go-live, follow:

• RELEASE.md

Also review:

• directives/production-playbook.md
• directives/launch-checklist.md

Scripts

Available npm scripts:

npm run dev
npm start

Notes For Contributors

If you are changing core order/admin flows:

• run the end-to-end smoke test again
• avoid mixing feature work with release fixes
• verify mobile and desktop before pushing