_      _         __      ___                           _       _   
     /\      | |    (_)        \ \    / (_)                         (_)     | |  
    /  \   __| |_ __ _  __ _ _ _\ \  / / _  _____      ___ __   ___  _ _ __ | |_ 
   / /\ \ / _` | '__| |/ _` | '_ \ \/ / | |/ _ \ \ /\ / / '_ \ / _ \| | '_ \| __|
  / ____ \ (_| | |  | | (_| | | | \  /  | |  __/\ V  V /| |_) | (_) | | | | | |_ 
 /_/    \_\__,_|_|  |_|\__,_|_| |_|\/   |_|\___| \_/\_/ | .__/ \___/|_|_| |_|\__|
                                                        | |                      
                                                        |_|                      

.- -.. .-. .. .- -. ...- .. . .-- .--. --- .. -. - 

Hi, I’m Adrian — thanks for stopping by.

I taught myself to code in high school after finding my dad’s three Turbo C floppies 💾. I booted the IDE, cracked open a C book, and hacked together a tiny sales tax calculator. That moment, turning curiosity into something useful, has stayed with me ever since.

Today, I explore modern stacks and apply them to a space I care deeply about: personal finance. From budgeting to investing, I’m interested in turning messy questions into simple, repeatable tools that save time and help people make better decisions.

Over the years, I’ve worked as an IT consultant, taking on both development and DevOps mandates. This dual experience has shaped how I approach building, deploying, and maintaining software.

• Simplicity first (KISS): keep things stupid simple. Fewer moving parts, clearer intent, easier maintenance.
• Clarity over cleverness: I’d rather ship a clear tool than a tangled masterpiece.
• Pragmatic engineering: readable code, sensible tradeoffs, solid defaults.
• Usefulness first: ship something helpful, then polish.

• Automate the boring stuff: repeatable, reliable pipelines save time and prevent mistakes.
• Everything as code: infrastructure, configs, and deployments should be versioned and reviewable.
• Fast feedback: short build/test/deploy cycles catch issues early and keep momentum high.
• Observability matters: logs, metrics, and alerts are essential for diagnosing and improving systems.
• Security is a habit: secrets management, least privilege, and regular updates are baked in, not bolted on.
• Collaboration over silos: devs and ops work together to ship, monitor, and improve.
• Simplicity scales: prefer simple, well-documented automation over clever complexity.

I'm building a lab of small repos where I deliberately try new frameworks, runtimes, databases, and architectural patterns. Exploring different stacks keeps me versatile and exposes me to new ways of solving common problems, helping me choose the best tool for each challenge with confidence.

What I actively explore:

• Backend runtimes to compare ergonomics and tradeoffs.
• Frontend frameworks (React, Svelte, Angular, Next.js, Astro) to refine rendering and component patterns.
• Data layers: lightweight SQL/embedded stores, serverless KV, and caching strategies.
• Dev experience tooling (linters, formatters, test runners) to tighten feedback loops.
• Deployment surfaces (serverless functions, edge runtimes, containers) to validate portability and cost profiles.
• And more...

Adaptability helps me avoid overengineering by choosing the simplest proven solution for each problem. Exploring different stacks broadens my perspective and reinforces simplicity in every project.

Curiosity drives most of these experiments. When something sticks, it often becomes a reusable template that I apply to my projects or simple explorations to scratch that new shiny tech itch. You’ll see these explorations appear as small, well‑labeled repos over time.

I’m passionate about personal finance as a craft, not just numbers, but habits, systems, and calm decision‑making. When I’m not coding, I’m often reading, sketching ideas, or testing small changes that compound over time.

Have an idea, question, or a tiny pain you wish a tool could fix? Reach out on 𝕏! I’m always happy to jam on ideas or collaborate on small, useful things.