7+ years building enterprise software for industries where failure isn't an option: banking, payments, and fintech. The current focus is applied AI in regulated environments — banks want LLM capability without sending a single byte to the public cloud. That's the problem I work on daily, in C#/.NET, Angular, and Rust, inside regulated banking environments. Client and employer names withheld; happy to walk through any of it under NDA.
An on-premise AI platform for financial institutions: multi-provider LLM routing behind one API surface, RAG pipelines with vector search, multi-agent orchestration, and zero external data egress — full data sovereignty for banks that can't ship data to a cloud model. Architected in C#/.NET.
Checkout flows, transaction processing, and fraud handling across 60+ third-party payment providers, spanning multiple regions and regulatory regimes. Owned the full e-commerce flow end to end — optimization work contributed to a 15% increase in conversion rates.
Currently building: a high-throughput access-control system in Rust — gRPC services over MongoDB and Redis. Plus ongoing monolith→.NET microservices migrations in banking environments.
Three builds, all sitting on top of a local Ollama daemon. Embeddings come from mxbai-embed-large, chat from whichever model fits the task. No API keys checked into anything, no provider lock-in — the cloud bridge is opt-in via the :cloud suffix when a model is too heavy to host.
Ingests document scans, runs OCR, then hands the raw text to a local LLM that classifies the document type and pulls out the fields that actually matter — dates, parties, totals, identifiers. Output drops into a searchable store, not a wall of unstructured text.
The unglamorous one. Embed a corpus, store the vectors, do a kNN lookup at query time, stitch the top chunks into the prompt, send it to the model. Built mostly to wire the moving parts together myself instead of trusting a framework — chunking, recall thresholds, and prompt budget all picked deliberately.
A single Go binary that talks to the local Ollama daemon and answers from inside the shell. Streams tokens as they arrive, keeps a session buffer, and stays out of the way — no browser tab, no auth dance, no leaving the terminal to ask a small question.
Four Claude personas — Philosopher, Contrarian, Romanticist, Analyst — argue a question in parallel. An Arbiter persona reads the four outputs and synthesizes a single answer. Dark grimoire UI, hand-drawn SVG avatars. Built to see if forcing disagreement produces better answers than asking one model twice.
// stream chat tokens straight to stdout
func stream(ctx context.Context, prompt string) error {
body, _ := json.Marshal(map[string]any{
"model": cfg.Model,
"prompt": prompt,
"stream": true,
})
req, _ := http.NewRequestWithContext(ctx, "POST",
cfg.Host+"/api/generate", bytes.NewReader(body))
res, err := http.DefaultClient.Do(req)
if err != nil { return err }
defer res.Body.Close()
dec := json.NewDecoder(res.Body)
for {
var chunk struct{ Response string; Done bool }
if err := dec.Decode(&chunk); err != nil { return err }
fmt.Print(chunk.Response)
if chunk.Done { return nil }
}
}local_first
cloud is opt-in, not default
no_framework_magic
wire the pieces by hand
small_models_first
reach for big only when needed