Backroundo is a multi-stage engineering project.
The goal is not to build every component immediately, but to gradually evolve a simple artwork viewer into a distributed digital museum platform.
Each phase should produce a working system before moving forward.
The core principle:
Build the museum room by room. Do not construct the entire building before hanging the first painting.
Create the project structure and establish architectural rules.
Create repository structure.
Define service boundaries.
Decide communication patterns.
Define configuration strategy.
Create Docker development environment.
Create documentation structure.
Suggested structure:
backroundo/
├── services/
│ ├── web-go/
│ ├── artwork-service-cpp/
│ ├── metadata-worker-cpp/
│ └── image-worker-cpp/
│
├── proto/
│ └── artwork.proto
│
├── infrastructure/
│ ├── docker/
│ └── kubernetes/
│
├── storage/
│
└── docs/
A clean project skeleton where every service can be started independently.
Build the smallest working version.
The first milestone:
One artwork exists in the system and can be viewed in the browser.
Browser
↓
Go Web Server
↓
Sqlite
↓
Image File
Database:
Artwork
id
title
artist
file_path
created_at
Features:
Add artwork manually.
Store metadata.
Display artwork.
Create artwork detail page.
Do not add:
RabbitMQ.
gRPC.
Search.
AI.
Kubernetes.
A working artwork page:
localhost/artwork/1
showing an image and metadata.
Stop treating images as ordinary files.
Move artwork assets into S3-compatible storage.
Possible solutions:
GarageHQ.
SeaweedFS.
Other S3-compatible storage.
Image
↓
Object Storage
↓
Database stores reference
↓
Browser loads image
Before:
file_path
After:
storage_key
Example:
originals/a8f92.jpg
Artwork images are managed through object storage.
Introduce service separation.
Browser
↓
Go Web Server
↓
gRPC
↓
C++ Artwork Service
Handles:
HTTP requests.
HTML rendering.
Browser communication.
Handles:
Artwork logic.
Database interaction.
Business rules.
The browser communicates with Go, and Go communicates with C++ through gRPC.
Move heavy operations into background workers.
Artwork Event
↓
RabbitMQ
↓
Worker
Create Metadata Worker.
Responsibilities:
Read filenames.
Extract metadata.
Update database.
Background processing works asynchronously.
Optimize image delivery.
Create Image Processing Worker.
Responsibilities:
Generate thumbnails.
Convert images.
Compress images.
Create different resolutions.
Example:
Original Image
↓
Image Worker
↓
thumbnail.webp
preview.webp
The application serves optimized images instead of huge originals.
Create the actual browsing experience.
HTML.
HTMX.
CSS.
Homepage.
Artwork pages.
Categories.
Gallery.
Downloads.
Use infinite scrolling.
The user sees:
24 artworks
↓
Scroll
↓
Load next 24 artworks
↓
Continue
Implementation:
Cursor-based loading.
Lazy-loaded images.
Thumbnail usage.
The application feels like a digital museum.
Make the archive discoverable.
Use Sqlite search.
Support:
Title search.
Artist search.
Style filtering.
Add Elasticsearch.
Architecture:
Sqlite
↓
Search Indexer Worker
↓
Elasticsearch
Features:
Fuzzy search.
Autocomplete.
Ranking.
Fast filtering.
Users can quickly find artwork in the archive.
Add advanced discovery features.
This phase is optional.
Purpose:
Understand visual similarity.
Pipeline:
Artwork Image
↓
Embedding Model
↓
Vector Representation
↓
Vector Database
Possible features:
Find similar artwork.
Search visually.
Discover related paintings.
Optional fallback.
Example:
Reverse Search Failed
↓
AI Classifier
↓
Estimated Style
AI should enhance the system, not become a requirement.
Turn the project into a reliable system.
Add:
Health checks.
Error handling.
Retry strategies.
Backup systems.
Rate limiting.
Input validation.
Secure communication.
Access control.
Logs.
Metrics.
Monitoring.
Alerts.
Prepare:
Docker images.
Kubernetes deployment.
Scaling rules.
Long-term vision:
Browser
|
Go Web Server
|
gRPC
|
Artwork Service
+-------------+-------------+
| |
v v
Sqlite Object Storage
|
RabbitMQ
|
+-------+---------+
| |
v v
Metadata Worker Image Worker
|
Search Indexer
|
Elasticsearch
|
Embedding Pipeline
|
Vector Database
Do not measure progress by services created.
Measure progress by capabilities unlocked.
The milestones:
One artwork displayed.
Artwork stored correctly.
Backend separated.
Background processing works.
Images optimized.
Museum interface exists.
Search works.
Intelligent discovery added.
Production quality achieved.
Backroundo becomes a private digital museum:
Massive artwork collection.
Efficient storage.
Fast exploration.
Intelligent search.
Scalable backend.
Clean user experience.
A system designed not just to display images, but to preserve, organize, and explore a growing digital archive.