Ruven. Swiss. ~7 years deep. Shipped real apps for real users — know the stack because I debugged it at 2am, not because I read about it.
~
whoami
Ruven Witzig
Developer who thinks in algorithms recursion logic automation efficiency _
Building everything from backends to mobile apps to neural networks.
If it can be automated, I've probably already built it.
~
rm -rf cv.pdf
Ruven Witzig
Developer who navigates by direction trade-offs systems intent vibes _
Same dev. Fewer bullet points.
Turns out the résumé was the real hallucination.
without AI
with AI
// flip it. watch the CV delete itself. // flip back if you miss scrolling through bullet points.
status_report.md
$ cat cv.pdf
cat: cv.pdf: No such file or directory
$ status --what-actually-matters
Agentic systems that don't hallucinate in prod. Interfaces that don't feel like they were designed by a committee of linters. Products that still work on a Tuesday.
Knowing which trade-off will cost you before you ship it. Knowing when "just prompt it" is the worst idea in the room. Understanding the system deep enough to disagree with the model — and be right.
01
About Me
// who I amI'm a developer who lives for logic. While my room might look like chaos, my codebase is immaculate—every variable named, every function documented, zero redundancy. // ironic, I know
Sure, a beautiful UI is nice—but nothing compares to a perfectly optimized, fully automated algorithm. That moment when O(n²) becomes O(log n)? Gorgeous. I build across the entire stack: web, mobile, APIs, neural networks—but my heart belongs to the logic underneath.
What I love about coding is the freedom. No barriers. Build something as big as Google from your bedroom—no money, fame, or permission required. Everyone starts equal. In your own codebase, you're basically a god of your own universe, shaping reality one function at a time.
Outside of code, I'm probably debating the Ship of Theseus, questioning whether true randomness exists, or going down a rabbit hole about the universe. I'm a firm believer that everything has an explanation—we just haven't found the right math yet. // determinism.exe loading...
My Philosophy
- Find structure in chaos — There's always a pattern
- Automate everything — If you did it twice, script it
- Efficiency matters — O(n) is nice, O(log n) is better
- Everything is explainable — We just need better tools
ruven.ts
interface Developer {
name: "Ruven Witzig";
passion: "Optimized Algorithms";
loves: [
"Problem Solving",
"Automation",
"Philosophy",
"The Universe"
];
believes: "Everything is explainable";
}
const me: Developer = {
// Simulating the Big Bang...
};
02
Skills
// what I work withFrontend
JavaScript
├──
TypeScript
daily driver
├──
React
│ ├──
Next.js
│ └──
Vite
⚡ fast
└──
Angular
CSS/SCSS
└──
Tailwind
└──
Bootstrap
Backend favorite
// where the real magic happens
Python
└──
FastAPI
Node.js
├──
Express
└──
Deno
exploring
C#
Java
PHP
└──
Symfony
Integrations
├──
Stripe
└──
Zod
Mobile
Native
├──
Swift
iOS
└──
Kotlin
Android
Cross-Platform
└──
React Native
└──
Expo
daily driver
└──
Ionic
Data
SQL
├──
PostgreSQL
daily driver
├──
MySQL
└──
Drizzle ORM
NoSQL
├──
MongoDB
└──
Firebase
Vector DBs
exploring
├──
Pinecone
├──
Sevalla
└──
Supabase
AI & ML
// how machines think fascinates me
Neural Networks
♥
├──
TensorFlow
└──
PyTorch
exploring
LLMs & RAG
daily driver
├──
OpenAI API
├──
Anthropic Claude
├──
Embeddings
├──
LLama
└──
Custom KBs
AI Agents
♥
├──
Tool Orchestration
├──
MCP
└──
Event-Driven Loops
DevOps & Infra
Version Control
└──
Git
daily driver
Deployment
├──
Docker
├──
CI/CD
├──
Heroku
├──
Deploio
🇨🇭 Swiss
└──
Sevalla
Realtime & Cache
├──
Socket.IO
└──
Redis
Currently Exploring active
// the rabbit holes I'm currently in
AI Agent Architecture
Building AI that acts, not just responds
MCP (Model Context Protocol)
Giving agents real-world tools
Agentic Memory & Planning
Context that compounds over time
Rust
Why not
Legacy ancient
// yes, someone still knows these exist
The Dinosaurs
├──
JavaFX
2014 vibes
└──
ColdFusion
sorry
03
Playground
// see algorithms in actionI love visualizing the beauty of algorithms. Here are a few interactive demos—tap to play!
Sorting Algorithm
Neural Network
LivePathfinding
04
Projects
// things I've shippedAI Products // founder & builder
Solmyr
LiveAI-Powered Business Companion for Founders
An AI co-founder that actually knows your business. Solmyr builds persistent context around your vision, then clears the path — planning, deep research, workspaces, governance-tier decisions, and proactive check-ins. Not just another chatbot, but a presence that compounds knowledge over time. Full SaaS with real-time collaboration, Stripe billing, and an agentic AI core with tool orchestration, event-driven loops, and MCP integration.
Mobile Apps
CodeSpark
App StoreAI-Powered Project Inspiration
Stuck on what to build next? CodeSpark generates personalized project ideas tailored to your skill level, interests, and available time—then creates your GitHub repository with a pre-populated README to get you coding faster.
HomieOS
App StoreShared Living Made Simple
A streamlined home management system for housemates and families. Features a beautiful 10-day calendar view, real-time event syncing, and a minimalist interface that makes coordination effortless.
Talentee
Coming SoonTalent Showcase & Booking Platform
A comprehensive platform for people to share their talents with the world. Features an automatic booking system, availability management, payments, reviews, and everything needed to turn talent into opportunity.
Professional Work // with enginess & clients
JuriCH
App StoreAI Legal Assistant for Swiss Law
An AI-powered legal assistant built with a custom knowledge base containing the entire Swiss law. Provides anonymous, secure legal guidance in plain language.
Graada
LiveOnline Exam Management
A comprehensive exam tool that enables schools to create, manage, and conduct online exams. Built for scalability and ease of use across educational institutions.
Intranet Sek II
LiveSwiss Secondary School Platform
The intranet platform used by most Swiss middle schools—Gymnasiums, vocational schools (Berufsschulen), and BMS. A large-scale system serving thousands of students and teachers daily.
KKST Intranet
LiveAI-Powered Enterprise Intranet
Custom intranet solution for a Swiss health insurance company, featuring AI integration with custom knowledge bases for intelligent document search and internal communication.
Developer Tools // open source utilities
ReleaseNotes
GitHubGenerate beautiful release notes from GitHub repos. Filter by milestone, tags, or date range—then export as Markdown or JSON.
i18n-fixer
GitHubAST-based tool to detect hardcoded strings in React/Expo projects. Auto-generates translation files and validates existing keys.
Decision Tree
GitHubVisualize and build decision workflows interactively. Perfect for mapping out complex logic and branching scenarios.
Redmine Upgrade
GitHubModern UI overlay for Redmine. Dashboard analytics, smart filtering, and a calendar view—making issue tracking actually enjoyable.
05
What I Build
// areas of expertiseProblem Solving
My actual love. LeetCode, work challenges, whatever—give me a complex problem and watch me disappear for hours finding the elegant solution. favorite
Neural Networks
Fascinated by how AI actually thinks. Not just using models—understanding architectures, activation functions, and why backpropagation works.
Vector DBs & RAG
Building intelligent search with embeddings and retrieval-augmented generation. Making AI actually useful with your own data.
DSGVO-Conform Solutions
Privacy-first development with Swiss-hosted infrastructure. Using DSGVO-compliant LLMs and servers—because data protection isn't optional.
Workflow Automation
If it can be automated, I've probably already built it. Turning manual processes into scripts that run themselves.
Developer Tools
Building tools that make development faster, easier, and more accessible. Good DX isn't a luxury—it's a multiplier.
06
Tech Explained
// complex ideas, simple words
If you can't explain it simply, you don't understand it.
Pick a topic, roll the dice, or read them all at 2am like a normal person.
How Neural Networks Work
Teaching machines to thinkImagine your brain as billions of tiny switches connected by wires. Each switch decides whether to pass a signal forward based on the signals it receives. That's essentially what a neural network does—but with math.
Neurons
Each circle is a neuron. It takes numbers in, does some math, and spits a number out. Simple as that.
Weights & Biases
The connections between neurons have weights—like volume knobs. They control how much influence one neuron has on another. These are the numbers the network learns.
Activation Functions
After summing inputs, neurons use an activation function (like ReLU or Sigmoid) to decide: "Should I fire or stay quiet?" This adds non-linearity—letting networks learn complex patterns, not just straight lines.
Learning (Backpropagation)
The network makes a guess, checks how wrong it was (the loss), then works backwards adjusting weights to be less wrong next time. Repeat this millions of times and it "learns."
TL;DR
Neural networks are layers of math functions that adjust their internal numbers through trial and error until they get good at recognizing patterns.
Vector Search & RAG
Search by meaning, not keywordsTraditional search looks for exact words: search "car" and it finds "car"—not "automobile" or "vehicle." Vector search understands meaning. It knows these words are related, even if spelled completely differently.
Traditional Search
"fast car" → LIKE '%fast%' AND '%car%'
❌ Misses "speedy automobile"
→
Vector Search
"fast car" → [0.8, -0.2, 0.5, ...]
✓ Finds similar meanings
Embeddings
Text gets converted into a list of numbers called a vector (or embedding). Words with similar meanings end up with similar numbers. "King" and "Queen" are close together; "King" and "Banana" are far apart.
Vector Distance
To find similar content, we measure the distance between vectors. Closer vectors = more similar meaning. It's like comparing coordinates on a map, but in hundreds of dimensions.
Vector Databases
Regular databases aren't optimized for "find the 10 closest vectors." Vector databases (Pinecone, Weaviate, Qdrant) use special indexing to make this lightning-fast, even with billions of vectors.
RAG (Retrieval Augmented Generation)
LLMs have a knowledge cutoff and can hallucinate. RAG fixes this: before answering, we search a vector database for relevant documents, then give those to the LLM as context. Now it answers based on your actual data—not just what it memorized during training.
TL;DR
Convert text to numbers, store in a special database, search by mathematical similarity. RAG uses this to give AI assistants access to your own documents.
The Beauty of Recursion
Functions that call themselvesTo understand recursion, you must first understand recursion. // This is the only acceptable recursion joke
Seriously though: recursion is when a function calls itself to solve smaller pieces of the same problem until it hits a simple case it can solve directly.
factorial.ts
function factorial(n: number): number {
// Base case: stop here!
if (n <= 1) return 1;
// Recursive case: call yourself
return n * factorial(n - 1);
}
// factorial(4) = 4 * 3 * 2 * 1 = 24Base Case
The base case is your exit door. Without it, the function calls itself forever (stack overflow!). It's the simplest version of the problem that you can solve directly.
The Call Stack
Each recursive call adds a "frame" to the stack—like stacking plates. When a base case is hit, the plates start coming off: each call returns its result to the one that called it.
When to Use It
Recursion shines for problems that are self-similar: tree traversal, nested structures, divide-and-conquer algorithms (merge sort, quicksort), mathematical sequences. If the problem contains smaller versions of itself, recursion is your friend.
The Catch
Recursion can be memory-hungry (each call uses stack space) and sometimes slower than loops. But for the right problems, it's so elegant that it's worth it. // readability > micro-optimization
TL;DR
Recursion breaks big problems into smaller identical problems until they're trivial to solve, then combines the answers back up. Elegant, powerful, and occasionally mind-bending.
Big-O Notation
How fast your code stays fast when things scaleBig-O describes how slow your code gets as the input grows. Not "milliseconds" slow — shape of the curve slow.
O(1)constantinstant. always.O(log n)logarithmicchef's kiss. binary search vibes.O(n)linearone pass. fine.O(n log n)linearithmicsorting. fair.O(n²)quadraticwhere side projects go to die.O(2ⁿ)exponentialrun. just run.
TL;DR
It's not how fast your code is today. It's how fast it stays when things scale. Senior devs obsess over this for a reason.
The Event Loop
How JavaScript fakes concurrencyJavaScript has one thread. So how does it do async? It lies — politely.
The event loop is a queue system: run all synchronous code first, then pick up callbacks from the queue one at a time. Microtasks (promises) cut the line. Macrotasks (timers) wait their turn.
order.js
console.log('1');
setTimeout(() => console.log('2'), 0);
Promise.resolve().then(() => console.log('3'));
console.log('4');
// logs: 1, 4, 3, 2 — and now you know why
TL;DR
setTimeout(fn, 0) doesn't fire immediately.
It waits for the stack to clear and for promises to finish first.
This is also why a busy loop freezes your UI.
Transformer Attention
Why GPT isn't actually thinkingTransformers don't "understand." For every token in your input, they score how much each other token should matter to it, then take a weighted sum.
That's it. Query, Key, Value. Dot products. Softmax. Stack a few dozen of those layers, train on the internet, and you get something that feels like thought.
TL;DR
The illusion of understanding is attention-weighted vector averaging. Very good math. Still math. // and yes, it still surprises me sometimes
Idempotency
Why double-clicking "pay now" shouldn't charge you twice
An operation is idempotent if running it once or a thousand times
produces the same result. GET is idempotent. DELETE is idempotent.
POST usually isn't — and that's the whole problem.
Not idempotent
POST /charge → -$10
❌ double-click = double charge
→
Idempotent
POST /charge + Idempotency-Key
✓ retries are safe
TL;DR
The network drops packets. Users double-click. Design APIs so retries don't cause damage. Idempotency keys aren't a nice-to-have — they're the difference between "sorry" and a refund.
07
Let's Connect
// get in touch // the part no model replaces
Got an interesting problem to solve? A system to architect?
Or just want to chat about the beauty of recursive algorithms?
$
send_message --to ruven
Say Hello
You've seen the map. You know where we're going.
The hard part was never the code.
$
open --conversation
Say Hello