avi✳A DEVELOPER'S FIELD NOTES
avi®

A story about things built, broken, and rebuilt.

AVI / SOFTWARE DEVELOPERAN EXPLORATION IN THREE CHAPTERS

INDEPENDENT MIND. BUILDER AT HEART.

Ideas
take shape.

Hi, I’m Avi. I turn restless curiosity into
thoughtful products and resilient systems.

FIG. 001 — A THOUGHT, TAKING FORMEVERYTHING STARTS SOMEWHERE.
↓SCROLL TO DISCOVER8 projects. One continuous thread.SELECTED EXPLORATIONS
2026 — ONGOING

Make life simpler. Make trust visible. Make systems resilient.

FOLLOW THE THREADTHE QUESTION KEEPS GETTING BIGGER.
01 / THE HUMAN SIDE

Make life
simpler.

An overloaded day. A missing backpack. A little friction that shouldn't be there.

I build software that gives something back.

Orbit↗Lost & Found↗RentFlow↗
02 / THE CONNECTIONS

Make trust
visible.

When people build together, the invisible matters. Who contributed? Who decides? What happens next?

Good systems make the answers clear.

OICE↗LegacyChain↗
EXPLORE THE WORK ↓
02 / The things I built08 EXPLORATIONS · OPEN SOURCE

Small questions.
Deep rabbit holes.

Some start with a person.
Some end up inside a database.

OPEN A PROJECT. SEE WHERE IT LED.
A MAP OF THE EXPLORATIONS

Different directions.
The same curiosity.

SELECT A POINT TO OPEN ITS STORY ↗
01Orbit02Lost & Found03RentFlow04OICE05LegacyChain06Compact SLM07TryCatchMe08Conflict-Free OLTP
A MAP OF MY CURIOSITY SELECT A POINT ↗
01

Orbit

SwiftUI · Apple platformsHuman
THE QUESTION

What deserves your attention right now?

Tasks live in lists. Time lives in calendars. Energy lives somewhere neither can see. Orbit brings that context together before asking you to do more.

THE EXPLORATION

Local, deterministic recommendations connect tasks, available time, and energy. The macOS planning timeline supports scheduling, resizing, and explicit confirmation of overlaps.

SwiftUISwiftDataLocal computationiOS · macOS · watchOS

PROJECT STATEFoundation · planning timeline implemented

Explore Orbit on GitHub ↗
INSIDE THE IDEAINTERACTIVE EXPLANATION
Orbit's actual iPhone interface showing Career, Health, and Learning orbitsFROM THE ORBIT REPOSITORY · iOS

Tasks, goals, available time, and energy become inputs to a local decision.

THE THREAD TO TAKE FORWARD

Software should respect your attention as much as your data.

02

Lost & Found

SwiftUI · On-device matchingHuman
THE QUESTION

How does a lost thing find its way home?

The owner has one half of the story. The finder has the other. Connecting them needs useful context, without exposing private identifying details.

THE EXPLORATION

Weighted matching compares category, name, description, location, color, and time. Private verification checks identifying details on-device; return coordination gives a match somewhere to go next.

SwiftUICoreLocationWeighted matchingPrivate verification

PROJECT STATEiOS implementation

Explore Lost & Found on GitHub ↗
INSIDE THE IDEAINTERACTIVE EXPLANATION
LOST
Blue backpackLibrary entrance↔FOUND
Blue backpackNearby report
15.0 / 15location points
One of six weighted factors.

A lost report and a found report describe an item from different perspectives.

THE THREAD TO TAKE FORWARD

A match is only useful if people can trust the next step.

03

RentFlow

Next.js · NestJS · MongoDBHuman
THE QUESTION

Can renting feel less like keeping a ledger?

A property, a payment, and a complaint mean different things to a tenant and a landlord. A shared system still needs to respect those different perspectives.

THE EXPLORATION

A monorepo separates the public site and three role-specific applications, backed by a NestJS API. The blueprint covers properties, tenancy, complaints, and manual payment verification.

Next.jsNestJSMongoDBRole-based applications

PROJECT STATEApplication monorepo · documented blueprint

Explore RentFlow on GitHub ↗
INSIDE THE IDEAINTERACTIVE EXPLANATION

The tenant experience brings payments, tenancy, and requests into one place.

THE THREAD TO TAKE FORWARD

One source of truth can have more than one point of view.

04

OICE

Solidity · Next.js · GeminiTrust
THE QUESTION

Who gets credit when everyone builds together?

Collaboration creates value long before it creates a finished product. OICE explores how contributions and funding decisions can leave an inspectable trail.

THE EXPLORATION

AI evaluates contributions with recorded reasoning. Ethereum escrow holds funding until approved milestones, while a lifecycle graph connects contributors, proofs, and rewards.

SolidityBase SepoliaGeminiMongoDB · IPFS

PROJECT STATETestnet protocol · deterministic demo mode

Explore OICE on GitHub ↗
INSIDE THE IDEAINTERACTIVE EXPLANATION

Code, research, design, or testing enters the project with supporting proof.

THE THREAD TO TAKE FORWARD

A reward means more when you can trace the reasoning behind it.

05

LegacyChain

Solidity · PostgreSQL · Next.jsTrust
THE QUESTION

What happens to a digital life when someone is gone?

Digital ownership creates a difficult tension: protect assets today, while making a deliberate path for the people who may inherit them.

THE EXPLORATION

An Ethereum vault pairs guardian consensus with proof-of-life signals. Encrypted letters, videos, and voice notes extend the idea beyond financial assets into personal legacy.

Base SepoliaGuardian consensusPrisma · PostgreSQLEncrypted legacy assets

PROJECT STATEETHGlobal project · Base Sepolia testnet

Explore LegacyChain on GitHub ↗
INSIDE THE IDEAINTERACTIVE EXPLANATION

ILLUSTRATIVE 2-OF-3 GUARDIAN VOTE

Trust takes more than one voice.

Vote to explore the threshold. No wallet or transaction.

A vault connects an owner, chosen beneficiaries, and encrypted personal content.

THE THREAD TO TAKE FORWARD

Trust is a human problem before it is a protocol problem.

06

Compact SLM

Python · FastAPI · llama.cppIntelligence
THE QUESTION

Does useful AI have to live in someone else's cloud?

Large infrastructure requirements make AI less accessible. This project starts with a smaller model and a clean interface that can grow with the application.

THE EXPLORATION

The first milestone serves local model chat through FastAPI and llama.cpp using GGUF models. Document retrieval and isolated company knowledge bases are roadmap work, not completed features.

PythonFastAPIllama.cppQwen3 · GGUF

PROJECT STATEMilestone 1 · local chat API

Explore Compact SLM on GitHub ↗
INSIDE THE IDEAINTERACTIVE EXPLANATION

A chat message reaches the FastAPI service through a REST endpoint.

THE THREAD TO TAKE FORWARD

Constraints can be the starting point of the architecture.

07

TryCatchMe

Python · AST · AI repairIntelligence
THE QUESTION

What if the debugger could try the next fix?

An exception is a symptom, not always the cause. Repairing code needs a loop that can inspect behavior, make a change, and check what actually happened.

THE EXPLORATION

A FastAPI repair engine combines semantic checks, AST transformations, and LLM fallback. The editor exposes patches, iteration logs, and output; a no-change guard bounds unproductive loops.

FastAPIAST transformationsLLM fallbackMonaco editor

PROJECT STATETryCatchMe · autonomous repair engine

Explore TryCatchMe on GitHub ↗
INSIDE THE IDEAINTERACTIVE EXPLANATION
ILLUSTRATIVE PATCH · BINARY SEARCH
while low <= high:
    mid = (low + high) // 2
    if values[mid] < target:
        low = mid

The pointer can get stuck on the same index.

Execution output and semantic checks provide evidence for the next attempt.

THE THREAD TO TAKE FORWARD

A convincing patch still needs to survive execution.

08

Conflict-Free OLTP

Rust · CRDTs · Distributed systemsSystems
THE QUESTION

Can independent writers find their way to the same truth?

Networks split. Writers disagree. Messages arrive late. A distributed database needs a principled way to bring those divergent histories back together.

THE EXPLORATION

A Rust backend and Next.js dashboard expose peers, conflict resolution, and replication. Network partitions, concurrent writes, and chaos controls make convergence visible.

Rust · Axum · TokioCRDTsWebSocketsReact Flow

PROJECT STATEDatabase experiment · observability dashboard

Explore Conflict-Free OLTP on GitHub ↗
INSIDE THE IDEAINTERACTIVE EXPLANATION

Disconnected peers continue making local changes without a shared timeline.

THE THREAD TO TAKE FORWARD

The interesting part starts when the network stops cooperating.

A LITTLE LESS TELLING. A LITTLE MORE SHOWING.

Some ideas make more sense
when you play with them.

03 / Get your hands on the ideaTHE CONVERGENCE EXPERIMENT

Two versions.
One truth.

Let two writers disagree. Change the delivery order. Send the same operations twice.

This working counter model lets you explore one idea behind Conflict-Free OLTP: independent histories can converge.

The full database project ↗
A SMALL, WORKING MODEL
REPLICA A INDEPENDENT WRITER
2[2, 0]
⊕TWO WRITERS. ONE STORY.
REPLICA B INDEPENDENT WRITER
3[0, 3]
APPEND-ONLY LOG 5 DELIVERIES
A:1+1A:2+1B:1+1B:2+1B:3+1
READY TO MERGE—

Add operations independently, then bring the replicas together.

A shared counter begins at zero. Two replicas can update their own component without waiting for each other.

A G-counter illustrates convergence here. A complete OLTP system needs additional transaction, constraint, and durability guarantees.

04 / Tools follow the questionPICK A THREAD. PULL ON IT.

Comfortable
being curious.

From the interface to the infrastructure.
I like understanding how the pieces fit.

Where an idea meets a person.

From responsive web products to native Apple interactions. I care about the small distance between intent and action.

ReactNext.jsSwiftUITailwind
05 / The open chapterFIELD NOTES / SEPTEMBER 2026

Still asking.
Still building.

The through line isn’t a particular technology.
It’s wanting to see how far an idea can go.

01 / HUMAN CONTEXT

Software that gives attention back.

Orbit ↗02 / SMALLER INTELLIGENCE

Useful AI, closer to home.

Compact SLM ↗03 / DEEPER FOUNDATIONS

What holds when things fall apart?

Conflict-Free OLTP ↗