I started writing code because I wanted to make things.

Then I started asking questions.

How does a browser talk to a server? What actually happens to the data? What happens when multiple users change something at the same time? How do you protect data that shouldn't even be visible to the database?

Most of my repositories are basically the trail of those questions.

• The journey
• 2024 — I started by making things
• Then I discovered applications
• Then backend became interesting
• Then I started thinking in real time
• Open Source
• Then security became a rabbit hole
• Real-time + Encryption
• Sometimes I just build tools for myself
• Physics → Software
• What I'm interested in now

small programs
      │
      ▼
web applications
      │
      ▼
backend & APIs
      │
      ▼
real-time systems
      │
      ▼
open source
      │
      ▼
security & encryption
      │
      ▼
systems & developer tools

My first projects were small.

A game. A calculator. A few web experiments.

Nothing fancy.

I was mostly trying to answer one question:

"Can I build this myself?"

A few of those early experiments:

🎮 Tic-Tac-Toe 🧮 Calculator 🐱 Cat Facts

Eventually, small experiments weren't enough.

I wanted to build things where multiple pieces had to work together.

That's where Connectify came in.

Frontend. Backend. Database. APIs.

Suddenly, writing code wasn't enough.

The pieces had to communicate correctly.

→ Connectify Frontend → Connectify Backend

The more applications I built, the more interested I became in the part users don't see.

Requests.

Data.

Authentication.

Business logic.

Performance.

And eventually:

"Why is this request taking 2 seconds?"

That's when backend stopped being just another part of the application and became the thing I wanted to understand deeply.

→ AI Chat Backend → Chat App

Request → response was only the beginning.

I wanted to understand what happens when systems need to communicate continuously.

That led me toward WebSockets, synchronization and eventually message brokers.

Projects like SketchSync and Encora came out of that curiosity.

→ SketchSync → Encora

At some point I stopped building only inside my own repositories.

I started fixing things in projects built by other people too.

PR #1463 — Update Norwegian Nynorsk translations

Merged into HeyPuter/main.

I updated the incomplete Norwegian Nynorsk translation, added missing keys, followed the project's conventions, and validated the changes.

→ View PR #1463

PR #15 — Fix theme change resetting editor content

Changing the editor theme was causing the application to reload and reset the user's code.

I fixed the theme handling so users could change themes without losing their current work.

→ View PR #15

2 merged PRs. Different projects. Different problems.

That's one of the things I like about open source — you don't control the whole codebase, so you have to understand the system before changing it.

Building APIs taught me how to move data around.

Security made me ask:

"What if the database itself shouldn't be able to read some of this data?"

That question eventually led me to MongoDB Client-Side Field Level Encryption.

Instead of implementing it separately in every application, I built:

A TypeScript utility library for MongoDB CSFLE with automated key and schema management and support for multiple KMS providers.

→ Mirage Encryption

And then I built something with it.

A small application demonstrating what happens when application data is transparently encrypted at the database layer.

→ TodoCrypt

       MIRAGE ENCRYPTION
          reusable layer
                │
                ▼
            TODOCRYPT
          actual usage

That curiosity also turned into Encora.

A real-time chat platform combining:

• WebSockets
• RabbitMQ
• MongoDB
• Web Crypto API
• ECDH P-256
• AES-256-GCM

The interesting part wasn't just making a chat application.

It was figuring out how all the pieces fit together.

→ Encora

Not everything needs to be a web application.

I wanted a terminal-first notes and reminder tool that I could actually use.

So I built Nikki.

SQLite. CLI. Background daemon. systemd. Notifications.

Small project.

Very useful.

→ Nikki

Before all of this, there was physics.

Some of my projects started as attempts to turn physics concepts into interactive software.

→ Optical Fiber Simulation → PhysXplore

Physics taught me to be curious about what's happening underneath the surface.

Software gave me another place to apply that curiosity.

I'm increasingly interested in the problems underneath applications:

Distributed Systems Backend Architecture Databases Networking Security Message-Driven Systems Linux & Infrastructure

I like taking an abstraction apart just to see what's underneath it.

backend systems
distributed systems
database internals
networking
security
infrastructure

Portfolio · LinkedIn · daily.dev

I usually don't start a project because I know how to build it.

I start because I want to know how it works.