I built something. Then I opened the dashboard to the public internet.

Not because I had to. Because I wanted to see what happens when you stop hiding how things work.

The Origin

I was building a personal site — a place to share what I'm working on, a landing page for conversations I wanted to have. At some point I wanted to know: is anyone visiting? What are they looking at? How long do they stay?

So I built telemetry. Then I built a dashboard to see it. Then I realized: why keep this private?

The metrics page at apps.codingenvironment.com/metrics/ is that dashboard. It's live. You can check it right now.

What It Shows

System health:

• CPU and memory usage
• Network I/O
• Process snapshots
• Inference activity when I'm running models

Visitor behavior:

• Which pages get traffic
• How long sessions last
• Where people came from
• What paths they take through the site

You can select time windows: last hour, last 6 hours, last 24 hours, or all time. Status indicators tell you if the data is live, stale, or missing.

How It Works

Backend: Django. Two models — SiteVisitEvent for visitor sessions, SystemMetricSnapshot for system health. A collector runs every 15 seconds and writes to the database.

Frontend: Vanilla JavaScript. No frameworks. Polls the API and renders charts.

Hosting: Single DigitalOcean droplet. I pay for it myself.

Third-party scripts: None. No Google Analytics. No tracking pixels. No ad networks. The only JavaScript running on the page is code I wrote.

The Privacy Tradeoff

I collect visitor data. That's the point. But I tried to do it responsibly:

• Visitor IDs are client-generated — stored in localStorage, not derived from IP addresses
• Session IDs use sessionStorage — they clear when you close the tab
• No third-party tracking — your data stays on my server
• Internal traffic is filtered — my own visits don't pollute your view

The one cookie I use is for testing: if I add ?internal_test=1 to a URL, it sets a flag so my own traffic doesn't show up in the dashboard. Normal visitors never see it.

I'm not claiming this is perfect privacy. It's not. But it's transparent — you can see exactly what I'm collecting because I'm showing it to you.

Built With AI

Every line of this was written with AI assistance. Not "AI wrote it" — I wrote it, with an AI suggesting, debugging, and reviewing alongside me.

This is how I work now. The metrics page isn't a demo of AI capability. It's an artifact of an AI-augmented workflow. The code exists because I built something I needed. The dashboard exists because I wanted to see it. The public page exists because I realized: if I'm willing to look at this data, maybe someone else would find it interesting too.

What You're Looking At

If you visit the metrics page, you're seeing:

• A Django app running on a $6/month droplet
• Real visitor sessions (yours will show up)
• System load from a machine I maintain
• Zero filtering — the data is what it is

It won't show anything impressive. That's not the point. The point is: it's there. You can verify it yourself. You don't have to trust my resume.

Why This Matters

I'm not sure it does. That's the experiment.

Most people keep their dashboards private. I get why — exposing operational data feels vulnerable. What if something breaks? What if the numbers look bad?

But I think there's something more vulnerable: claiming you can build systems and then asking people to trust you without evidence.

So here's the evidence. It's live. It might break. The numbers might look unimpressive. But it's real.

This Is Bigger Than One Page

The metrics page is one artifact. The broader project is:

A PKM/PIM cognitive augmentation system — personal knowledge management and personal information management, designed to extend how you think, not just store what you know. Your notes, your calendar, your tasks, your history — all connected, all searchable, all reasoning-capable.

AI-augmented everything — not just coding, but writing, researching, planning, communicating. The agent doesn't replace you. It remembers for you, reasons with you, surfaces connections you'd miss.

Transparency as default — the metrics page is public because I think the future of technical work is showing your work. Not polishing a resume. Publishing the process.

What Happens Next

I'm not sure. That's the experiment.

The page is live. It might break. The numbers might look unimpressive. But it's real, verifiable, and honest about what it collects.

If you're building things — software, analytics, knowledge systems — consider publishing your own telemetry. Not as a flex. As evidence that you're building in the open, learning in public, and willing to let others see how it works.

This is the new way to do technical work. Not hiding. Not polishing. Publishing.

apps.codingenvironment.com/metrics/

That's the artifact. The philosophy is what you do with it.