Docker · WSL · PostgreSQL · matching logic · self-hosted experiments
Overview
Found.me is an in-development product build I use to connect full-stack architecture, Docker-based local infrastructure, WSL workflows, PostgreSQL modeling, and automation around matching and notifications.
I am keeping the public description intentionally compact. The project name gives the direction, while the case study focuses on what I am learning and building: services, data flow, matching signals, notifications, and a possible self-hosted path.
The first practical context is Munich. The goal is to build the system carefully enough that it can move from local experiments toward a real deployment later.
Why this project exists
I wanted one personal product that forces me to learn more than UI work. Found.me gives me a reason to work with API design, database structure, Docker networking, background workflows, and deployment constraints in one place.
The value for my portfolio is the learning path itself: taking an idea, breaking it into services, and building the infrastructure needed to make it real.
System structure
Core modules
Full-stack foundation
The project is being built as a real product structure, not only a static prototype. I use it to connect frontend routes, backend APIs, database tables, and automation workflows into one system.
Matching and search logic
The core logic is based on structured signals such as category, city, date, keywords, and image metadata. The first version stays explainable before adding more advanced AI features.
Docker and WSL workflow
A major goal is learning how to run a multi-service application locally with Docker from a WSL environment, then use that setup as a base for self-hosted deployment experiments.
Automation layer
n8n is planned as the automation layer for scheduled match checks, notification flows, reminders, and manual review tasks. This keeps workflow logic separate from the core API.
Munich-first direction
The first deployment context is intentionally local. The project is small enough to build and test, but broad enough to show product thinking, infrastructure learning, and practical automation design.
Technical decisions
Keep the product idea understated
The public page does not explain the full concept directly. It shows enough architecture and signals for a technical reviewer to understand the direction without turning the page into a pitch deck.
Learn infrastructure through one product
Docker, WSL, PostgreSQL, and self-hosted deployment are not listed as theory. They are tied to one product build with services that need to run together.
Start explainable before advanced AI
The first matching logic uses clear scoring rules. AI image comparison and deeper automation can come later once the base system is stable.
Document progress honestly
The project is marked as in development. The public repository documents architecture experiments and snippets, not a finished production platform.
Proof / Evidence
This page documents an active learning build. The public proof focuses on architecture notes and small snippets for matching logic, Docker planning, and service boundaries. It does not claim that the product is already deployed.
Public proof shown on this page
A planned architecture diagram for the Found.me learning build: frontend, API, database, storage, matching worker, automation workflows, notifications, and Docker-based local infrastructure in WSL.
Public code & documentation
Architecture notes and early snippets from an in-development full-stack product build focused on matching signals, Docker, WSL, PostgreSQL, self-hosted infrastructure, and automation workflows.
Code excerpt: match scoring helper
The snippet shows an early, explainable matching pattern. It is intentionally simple while the infrastructure and data model are still being shaped.
type MatchSignal = {
category?: string;
city?: string;
date?: string;
keywords?: string[];
imageHash?: string;
};
export function scoreCandidate(source: MatchSignal, candidate: MatchSignal) {
let score = 0;
if (source.category && source.category === candidate.category) score += 30;
if (source.city && source.city === candidate.city) score += 20;
if (source.date && source.date === candidate.date) score += 15;
const sourceKeywords = new Set(source.keywords || []);
for (const keyword of candidate.keywords || []) {
if (sourceKeywords.has(keyword)) score += 5;
}
if (source.imageHash && source.imageHash === candidate.imageHash) score += 25;
return {
score,
shouldReview: score >= 45,
};
}Publication note
Found.me is currently an in-development learning build. Public documentation should describe architecture, progress, and experiments without presenting unfinished parts as production-ready features.