Skip to content

Boris Nikolic

Software developer · Belgrade, Serbia

I build platforms and ship software with AI as my daily pair.

Started with robots in middle school, got hooked on Linux in a VM, learned the trade through Hack The Box, C#/.NET systems, and frontend work in high school, and I've spent the past four years going from frontend-only work to full-stack platforms while finishing a Software Engineering degree.

Backend services and APIs: Go, Python, NestJS; REST design, auth, gateway-fronted services

Odoo modules and PostgreSQL: ERP modules, query optimization, triggers, reporting over large datasets

ERP integration and data replication: Odoo data into analytical warehouses, built for reliable delivery

AI-assisted engineering: briefs, plans, and reviews with an agent daily; MCP tools acting on pipelines and infrastructure

Full-stack delivery: React, Angular, and Next.js frontends; Express, Laravel, Django, and Spring Boot backends; JWT auth, payments, admin tooling

Linux and self-hosting: Ubuntu servers, iptables firewalls, SSH hardening, monitoring, Docker Compose

Working with stakeholders: Requirements gathered directly, trade-offs explained in plain language, modules and features shipped, tested, and tailored to the production VPS

contactresumeworkai workflow

Type a command and press Enter. Tab completes, arrow keys browse history, Ctrl+L clears.

How I work with AI

AI is how I build now, and I enjoy the craft more because of it. Not autocomplete on the side: an agent in the terminal all day, briefed like a teammate. The loop stays the same whether the codebase is years old or an empty directory: brief, plan, build with tests, review, verify, document. The agent gets the same context a new colleague would, written down in the repository.

loop

Every task, every repository, the same six steps.

  1. briefA written brief with goals, constraints, and integrity rules: what the agent may and may not invent.
  2. planBrainstorm, then a written plan before code. Specs and plans are committed next to the code.
  3. buildSmall tasks, tests first where the stack allows. The agent works from CLAUDE.md and the docs hierarchy, not from chat memory.
  4. reviewAI review passes (code review, security review) followed by my own read of every change.
  5. verifyLint, build, run, and drive the actual app before anything is called done.
  6. documentSTATUS, CHANGELOG, and open-question files so the next session, human or agent, starts with context.

prompting

Prompts are repository files with a job, a reading order, rules, and a done checklist. They are versioned like code and reviewed like code.

  • Role prompts per job: a Builder prompt for features and fixes, a Testing prompt for coverage, each with its own goal, workflow, and checklist.
  • A docs hierarchy the agent reads first: CONTEXT.md, STATUS.md, coding standards, and the security remediation plan.
  • Hard rules as NEVER / ALWAYS lists (no secret logging, parameterized SQL, crypto/rand only) that come before style preferences.
  • A reporting format for finished work: what changed, files, tests added, breaking changes, next steps.
  • An example session in the prompt so the agent sees a full loop, not just rules.
  • Tool inventory in CLAUDE.md: which commands, plugins, and MCP servers exist, so the agent uses real tools instead of guessing.

day to day

A daily pair, not a chat window. Every repository carries its own setup, so a session starts knowing the project instead of asking about it.

a codebase I'm new to
The first session is orientation: the agent reads the repository and writes down what it learned (stack, commands, architecture, rules), so every session after starts productive.
from the ground up
Brainstorm before code: goals, constraints, and trade-offs argued out with the agent, a plan written and committed next to the code, then small tasks with tests first.
the everyday
Features, fixes, debugging, and reviews run the same loop, with planning, review, and verification checklists so quality does not depend on the day.
memory and specs
Persistent memory files plus written specs and plans committed next to the code, so the next session, human or agent, picks up where the last one stopped.

real systems

The agent does not just write code, it acts. MCP servers give it real tools instead of pasted output, declared per project so it knows exactly what it can call.

GitLab
Pipeline automation from Claude: merge requests, pipeline status, and job logs without leaving the session.
cloud infrastructure
Managing infrastructure resources through MCP tools, with the same review loop as code changes.
issue and ops trackers
GitHub, Jira and Confluence, Linear, Datadog, and PagerDuty connectors from the engineering plugin, enabled per project.
browser
Claude drives a browser against the running app: screenshots, console, DOM checks, keyboard navigation.

environment

The tools around the agent, all terminal-first.

  • Neovim (LazyVim) as the editor
  • tmux and lazygit in the terminal
  • Linux on every machine
  • Claude Code and Codex as the agents; local LLMs for experiments

Case studies

Two entries: client work on Odoo for Fairphone, and a full-stack personal project. The client page says only what the engagement allows.

  • client work

    Fairphone

    2025 – present

    fairphone-odoo-platform/ Client Work: Odoo Platform for Fairphone

    Platform work for Fairphone on Odoo: modules for sustainability and procurement operations, replication of ERP data into analytical warehouses, and the architecture of a customer-facing shop. Described at the level the engagement allows.

    role: Software developer

    • Odoo
    • PostgreSQL
    • Data replication

  • personal project

    University project

    toy-store/ Toy Store: Full-Stack E-commerce

    A full-stack e-commerce application with a Go API, a Next.js 14 frontend, PostgreSQL, Redis-backed sessions and caching, Stripe checkout, and an admin dashboard, run as one Docker Compose stack behind Nginx.

    role: Developer

    • Go
    • Next.js
    • PostgreSQL
    • Redis
    • Stripe

50+ personal and client projects since school. Most are private, old, or under agreements not to talk about them. The ones on this page are the ones I can show.

Working with people

  • Requirements gathered directly from the people who use the software, then turned into a scope both sides understand.
  • Technical terms and trade-offs explained in plain language, so non-technical stakeholders can decide on priorities and timelines with the full picture.
  • Modules and features shipped end to end: built, tested, and tailored to the client's production VPS.
  • Alongside the stakeholders from the first requirement to delivery, so what ships matches how they actually work.

Also built

  • Control Management System Platform

    Multi-role CMS web application with authentication, order management, revenue reports, a notification system, and role-based access control.

    Go · Next.js · React · TypeScript · PostgreSQL

  • RPG campaign manager (university coursework) (opens in a new tab)

    Final project for the Internet Software Architecture course: a Spring Boot REST API with JWT access and refresh tokens and role-based authorization, a React SPA, PostgreSQL, and Docker Compose. Game masters run campaigns, sessions, and item catalogs; players manage characters and inventories.

    Java 21 · Spring Boot · PostgreSQL · React · Docker Compose

  • HTTP forward proxy in C++ (opens in a new tab)

    Multi-hop HTTP forward proxy on native sockets: an HTTP server with GET and POST handling, single-hop forwarding, and chained routing through several proxy nodes. Layered AES and RSA encryption between hops is in progress.

    C++ · Sockets · AES/RSA

  • Terminal password manager in C++20 (opens in a new tab)

    Secrets stored in PostgreSQL under a hybrid scheme: each password encrypted with a fresh AES-256-GCM key, that key GPG-encrypted to your key's fingerprint, so the same vault opens on any machine holding the key. CMake build, Docker Compose for the database.

    C++20 · PostgreSQL · GPG · AES-256-GCM · CMake

Home lab

Hosting my own servers and VMs, configuring and hardening them, attacking and defending them, and automating the whole thing.

servers:
Self-hosted Ubuntu machines, including a Forgejo git forge for my own repositories.
vms:
Locally hosted VMs for privacy and security work: Qubes OS and Whonix.
anonymity:
Self-hosted chats and servers for anonymous communication: onion services on Tor, garlic-routed services on I2P.
network:
Home network and custom iptables firewall rules for the self-hosted services.
hardening:
SSH hardening automated end to end with a script I built after researching what hardening should cover.
security:
Penetration testing, red team and blue team practice, all against my own lab.
monitoring:
Grafana and Prometheus over the whole stack.
experiments:
Local blockchains, for learning.
origins:
Hack The Box: Linux, Git, Nmap, Kali Linux.

About

I write software for work and for fun. Four years of professional work: started on the frontend, followed the requests into the backend, now the full stack, backend first. Most of the recent work has been backend and data systems: Odoo modules, ERP data replication, and the services around them. Beside the home lab, the rest of the time goes into finishing university.

AI is my daily pair: I brief it like a teammate, plan with it before code, and read every change before it ships. The craft got faster without getting less mine. I love what I do.

university

BSc Software Engineering. Enrolled in 2023, finishing by the end of 2027, working as a software developer alongside it.

off the keyboard

  • Sim racing, Counter-Strike, and cars.
  • The gym, trying to stay in shape.
  • A good meal: pasta, or anything protein-rich.

How I work

Model the domain before the endpoints
Schemas, states, and invariants come first. APIs and screens follow from them.
Design for failure
Acknowledgments, retries, and idempotent steps, so a crash midway becomes a retry instead of a data gap.
Measure the database
Query plans and real data volumes before optimizing. PostgreSQL usually has the answer.
Keep boundaries clear
Layers and services that can be understood, tested, and changed on their own.
AI writes, I answer for it
Agents work from written briefs and rules; every change is read, understood, and verified by me.
Automate what would otherwise repeat
If something has to be done twice, it gets a script: server hardening, pipelines, reports.

Technologies, grouped by how I've used them

First-level items are in regular use on client and personal work; entries marked (also) are used less often or in specific projects.

  • Languages/

    Go for services and CLIs, Python for Odoo, Django, and tooling, C and C++ for systems and networking work, Rust for a client platform, TypeScript across NestJS, Express, Angular, and Next.js, SQL daily in PostgreSQL.

    • Go
    • Python
    • TypeScript
    • C/C++
    • Rust
    • SQL
    • JavaScript (also)
    • PHP (Laravel, plain PHP MVC) (also)
    • Java (Spring Boot) (also)
    • C# (.NET, high school systems work) (also)

  • Backend and APIs/

    Odoo module development, layered Go services, NestJS and Express APIs with JWT auth and role-based access, and MVC frameworks (Laravel, Django, Spring Boot) on client and university work.

    • Odoo module development
    • Go (Gin, chi)
    • NestJS / Node.js
    • Express
    • REST API design
    • JWT auth and RBAC
    • Laravel (also)
    • Django (also)
    • Spring Boot (also)
    • Stripe integration (also)
    • API gateway pattern (also)

  • Data and storage/

    PostgreSQL as the system of record: query optimization over large datasets, triggers, migrations. Redis for caching and sessions. An ORM where the stack calls for one.

    • PostgreSQL
    • ERP data replication
    • Redis
    • Query optimization
    • MongoDB (also)
    • SQLite (also)
    • Analytical warehouses (also)
    • Prisma (also)
    • TypeORM (also)
    • Mongoose (also)
    • Spring Data JPA (also)

  • Messaging and workflows/

    Asynchronous pipelines with RabbitMQ, scheduled jobs, and reliable delivery for data replication.

    • RabbitMQ
    • Event-driven design
    • Scheduled jobs
    • Reliable delivery

  • Frontend/

    Next.js App Router with server components where it helps SEO and data loading, React with Vite and React Router on personal projects, Angular on the frontend job, client work, and coursework.

    • React
    • Next.js (SSR)
    • Angular
    • Tailwind CSS
    • React Router (also)
    • Redux Toolkit (also)
    • Vite (also)
    • Zustand (also)
    • Zod (also)
    • Axios (also)

  • Infrastructure and operations/

    Self-hosted Ubuntu servers in the home lab with Grafana and Prometheus over them, Bash for the automation, and a Docker Compose setup with a reverse proxy where needed on every project.

    • Linux
    • Ubuntu servers
    • Bash scripting
    • Docker and Docker Compose
    • Nginx
    • Grafana
    • Prometheus
    • GitHub Actions (also)
    • GitLab CI (also)
    • Forgejo (self-hosted) (also)
    • Vercel (also)
    • Makefiles (also)

  • Security and networking/

    Hack The Box is where this started; the home lab is where it is applied. Networking from the socket up in C and C++: a multi-client HTTP server, and a multi-hop HTTP forward proxy with layered encryption in progress.

    • Penetration testing
    • iptables firewalls
    • SSH hardening (automated)
    • Socket programming (C/C++)
    • Nmap
    • Kali Linux
    • Red and blue team practice (also)
    • Qubes OS (also)
    • Whonix (also)
    • Tor and onion services (also)
    • I2P (garlic routing) (also)
    • HTTP servers and proxies from scratch (also)
    • PGP handling (also)
    • Data encryption (AES-256-GCM, GPG) (also)

  • Architecture and practices/

    Distributed data movement with explicit failure handling, clean layer and service boundaries, MVC where the framework is built around it, and domain models that match how the business actually works.

    • Distributed systems
    • Domain modeling
    • Layered (clean) architecture
    • MVC (Laravel, Spring MVC, Django)
    • Caching strategies
    • Fault-tolerant data pipelines
    • Automated tests (Jest) (also)

  • AI-assisted workflow/

    An agent in every repository: briefed from files committed next to the code, planning before code, reviewing before merge, and acting on pipelines and infrastructure through MCP.

    • Claude Code
    • Codex
    • CLAUDE.md and role prompts
    • superpowers plugin
    • engineering plugin
    • MCP servers
    • qodo-standards plugin (also)
    • Local LLMs (also)

  • Tools/

    Terminal-first: Neovim with LazyVim (configured in Lua), tmux, lazygit, Git.

    • Neovim (LazyVim)
    • tmux
    • lazygit
    • Git
    • Lua (Neovim config) (also)

How I got here

From school robots to shipping software, one commit at a time.

  1. feat: software developerFrontend and backend at once since then: full stack. Four years of professional experience in software development. Today: Odoo modules and data systems for Fairphone, with AI as a daily pair.
  2. feat: backend serversGot introduced to backend servers while the paid work was still frontend websites.
  3. feat: frontend developerFirst year of professional work: frontend only, building web frontends, Angular included.
  4. feat: software engineering, universityBSc Software Engineering: enrolled in 2023, finishing by the end of 2027.
  5. feat: hack the box, high schoolHack The Box is where Linux, Git, Nmap, and Kali Linux really came from. Same years: C# and .NET systems, and custom frontends in HTML, CSS, and JavaScript, then React.
  6. feat: linux in a vmGot hooked on Linux running in virtual machines on Windows 10.
  7. init: robots, middle schoolFirst programs, written for school robots in a language long since forgotten. The interest stuck.

education: Bachelor of Software Engineering, enrolled 2023, finishing by the end of 2027

Open to interesting projects and opportunities

Backend-heavy full-stack roles and contract work, especially data and integration systems. Email is the fastest way to reach me.

borisnikolic2302@gmail.com
resumedownload pdf
HELPkeybindings~/prtf/help.md

Keyboard

g h
home
g a
ai workflow
g w
work
g l
home lab
g s
skills
g e
experience
g c
contact
g r
resume
:
focus the shell
?
toggle this help
Esc
close

Shortcuts are ignored while typing in a field.