Skip to main content
anton.social // Self-hosted Estate // Reference Topology

System Architecture

Everything behind anton.social runs on a single server I own — no rented cloud. This is the full map: how a visitor's request travels from the edge of the internet, through a private cloud and a stack of containerised apps, and back again.

Reference_Architecture // Layer Flow

Every request travels top-to-bottom through seven layers — from the public edge of the internet down to stored data. Here's that path at a glance; explore it live on the interactive map below.

Interactive_Map // Click to explore

Click the map to zoom and drag around it like a canvas; press Esc to scroll the page again. Click any service for a plain-English explanation, or run Trace request.

Cloudflare EdgeDNS · CDN · WAF · Tunnel
The internet's front desk. It finds the right address, blocks bad traffic, and hands the request to a private tunnel — so the server never exposes a door to the open web.
Object Storage
Files, images & backups.
Secrets
Passwords & keys, locked away.
Lenovo ThinkSystem SR250 V3 · DebianBare-metal host
One physical server in a rack, running Debian Linux. This single machine is the foundation everything else lives on.
Perimeter & Networkfirewall · switch · proxy
The gate and the wiring — it decides what traffic may enter the network and routes it inside.
OpenStack Private Cloud10.20.30.0/24 · example
My own private cloud running on the server — a personal, self-hosted version of AWS that carves the machine into virtual networks and computers.
Load Balancingedge + control plane
Container OrchestrationDocker · Compose · K8s
Each app is packed into a container — a sealed box with everything it needs — so it runs the same way anywhere and can be scaled or replaced instantly.
Web Tier · Frontend
What visitors actually see — the website, its pages and interface.
App Tier · Backend
The brains behind the scenes — business logic and APIs the website calls.
Data Tier · DB Subnet
Where information is stored long-term and cached for speed.
CI/CD & IaC
Builds, tests & ships new code.
Observability
Dashboards & alerts keep it healthy.
Design & Docs
Where it's designed & written down.
Idle — click a service to inspect, or trace a request.
100%
Click to explore · drag to pan · scroll to zoom
Drag to pan · scroll to zoom · Esc to scroll the page
Core pathRunning / dataBuild & automationSecurity & insightLines show request flow · animated on trace
How_A_Request_Travels

The same journey the Trace request button animates above — in plain words. Each step lights up as the trace runs.

01
A visitor opens anton.social in their browser.
02
Cloudflare finds the right address and blocks anything malicious.
03
The request slips through a private tunnel — the server has no open doors.
04
A firewall double-checks the traffic is allowed onto the network.
05
Traefik decides which app should handle it and forwards it on.
06
A container builds the page with Next.js, the website framework.
07
The NestJS API gathers whatever data the page needs.
08
The database returns it — and the finished page travels all the way back.
The_Stack // Layer By Layer

Seven layers carry a request from the public internet down to stored data, with five supporting tracks running alongside. Here's what each one is and why it's there. Click a technology to open its detail on the map.

01
Edge & DNSPublic ingress

The public front door, run entirely by Cloudflare.

Keeping DNS, caching, the firewall and a zero-trust tunnel at the edge means attacks are filtered far from the server and no inbound port is ever opened — the origin stays invisible.

02
Perimeter & NetworkFirewall · switching

The gate and wiring inside the building.

A hardware firewall and managed switch zone the network and decide what may move where, with NGINX serving and proxying at the edge of the estate.

03
Compute & Private CloudBare metal · IaaS

One physical server turned into a private cloud.

OpenStack on bare-metal Debian gives an AWS-like control plane — virtual machines, networks and identity — so workloads are provisioned on my own hardware instead of rented cloud.

04
Containers & OrchestrationBuild · ship · scale

Apps packed into portable, replaceable boxes.

Docker images give identical runs everywhere; Compose and Kubernetes start and heal them; Harbor stores them — so deploys are repeatable and rollbacks are instant.

05
Application · FrontendWhat you see

The website and everything you interact with.

Next.js and React in TypeScript build fast, SEO-friendly interfaces; SASS keeps styling maintainable; Payload manages content without touching code.

06
Application · BackendThe logic

The brains the website talks to.

NestJS and .NET expose clean, documented APIs built spec-first with Swagger — structured, typed and testable business logic.

07
Data & StatePersistence

Where information lives and is cached.

PostgreSQL is the source of truth, MongoDB holds flexible documents, and Redis caches hot data so the site stays fast under load.

08
CI/CD & Infrastructure as CodeCross-cutting

How code and infrastructure ship automatically.

GitLab and Jenkins build, test and deploy on every change; Terraform and Ansible define the whole estate as code — reproducible and version-controlled.

09
Secrets & IdentityCross-cutting

Where credentials are kept safe.

Vault issues and rotates secrets so nothing sensitive is hard-coded; Vaultwarden holds operator logins.

10
Observability & QualityCross-cutting

Keeping the estate healthy and the code clean.

Prometheus measures, Grafana visualises and alerts, and SonarQube gates code quality before anything ships.

11
TestingCross-cutting

Proving it works before users do.

A test pyramid — fast unit tests with Jest and the Node runner, full user-flow checks with Cypress.

12
Design & DocumentationCross-cutting

Where it's designed and written down.

Figma and Photoshop shape the interface; Obsidian documents every decision, runbook and the estate map itself.

Principles_&_Practices

The conventions that keep a one-person estate maintainable.

Clean architecture

Backends follow EBI / clean-architecture boundaries and SOLID principles, so logic stays testable and swappable.

API-first

Contracts are designed in Swagger before code — the spec is the single source of truth for every endpoint.

Gitflow

Feature, release and hotfix branches with reviewed merges; every change runs the pipeline before it lands.

Infrastructure as Code

Terraform's root-and-leaf model plus Ansible mean the whole estate is reproducible from version-controlled text.

Zero-trust & least privilege

No open inbound ports; a tunnel at the edge and Vault-issued, short-lived secrets everywhere inside.

Everything containerised

One Dockerfile per service makes local, staging and production behave identically and rollbacks trivial.

0
Server I own & run
0
Layers, edge to data
0
Self-hosted services
0
Open ports to the web