Fran Hrženjak

I worked as a tech lead and main developer on a project to computerize a large, 1-meter (diameter) 24-ton telescope at the astronomical observatory on Tičan, Croatia. This is an ongoing multi-year effort, and a combination of professional and volunteer work. The telescope began operating full-time in 2017, and in 2018, it ranked third worldwide in the number of confirmation and follow-up measurements of newly discovered asteroids.

This is an in-house solution for an air traffic controller training center. New candidates for air traffic controllers go through extensive simulations, called games, in which instructors put them through various simulated situations in air traffic control that they then have to correctly resolve in real time.

Before this project, the candidates and instructors who set up and ran the games communicated using ad hoc solutions such as WhatsApp or Viber, or sometimes by walking up to each other to share changes to the game. This was very inefficient and often ruined the element of surprise that the instructors were trying to create for candidates. To facilitate better communication between candidates and instructors, the client envisioned a centralized system to which every pilot would connect using their PC, and every instructor would connect via a custom mobile app.

My job was to take the client's specifications and talk with them to understand their problem fully. After this, I assembled all the technologies and techniques needed for the project, i.e., I architected the solution. Finally, I integrated a design and implemented the system.

I was added to the "authors" list for Django, my favorite open-source web framework, for fixing a bug that was sitting for nine years in the admin interface.

I am proud of the achievement, and hope to contribute again in the future.

Original bug report: #15910
I worked from a newer report, but same bug: #29087

A collection of sites for the Danish Ministry of Foreign Affairs. Each site is dedicated to one official visit of a business and state delegation to another country.

Each site features:
• Public section, with content and structure fully editable via CMS
• Registration and logistical information for participating company representatives
• Elaborate administration interface that aids the organizer team

There are three sites thus far:
https://hr2014.urbandanish.solutions/ (previously https://danishstatevisit.hr/)
https://danishstatevisit.dk/indonesia2015/
https://danishroyalvisit.dk/italy2018/

Developed in Django/Python. The front end was outsourced and is based on Bootstrap.

As of 2019, the project is still public and has been forked/pivoted to another type of events (organized by Danish Embassy in Zagreb). These events are more focused on a single industry at the time, e.g:
https://www.urbandanish.solutions/smartcities2017/
https://www.urbandanish.solutions/smartislands2018/
https://www.urbandanish.solutions/watercroatia2019/

Screenshot are available here: http://changeset.hr/portfolio/danishstatevisit-hr

A fully customizable front page slider driven by the WordPress admin panel.

A user-friendly (point and click) Google Maps tool for the Django admin panel that was developed for a tourist service.

A Croatian e-learning platform for the University of Rijeka that is based on Django. I created the back end, which features multiple courses, user registration, signup for courses, video lessons (YouTube), and quizzes.

A fully customizable layout template solution that I created to address inconsistent layouts between content types.

The project involved interacting with PLC devices, encompassing reading and writing operations. I successfully accomplished the coding task within 48 hours, including an additional sub-task of containerizing the project and publishing it online.

Several key features include:

• Implementation of a dummy PLC reader module designed for testing purposes.
• Utilization of Celery for background tasks
• Incorporation of a graphical representation illustrating the uptime and downtime of each device
• Provision of a feature to download the graph mentioned above as a PDF generated on the server side
• Full containerization of the project through Docker Compose, facilitating swift local deployment

I can provide a concise file containing PLC reader classes upon request. This file illustrates class inheritance, type annotations, and commenting. The class in use, whether FakeReader or PLCReader, is determined by the project settings file, where it is configured as a string value for dynamic import. This approach resembles how Django configures middlewares and other dynamically loaded elements.

SysStat is a lightweight monitoring tool I built for Raspberry Pi devices with the PiHut StatusBoard hat. It monitors up to five networked devices using LEDs, which indicate online status with green and offline status with red. Simple as that.

The system periodically pings your devices (servers, workstations, IoT gadgets, etc.) and activates the corresponding LED. No dashboards or logs to check—just glance at the board. Perfect for home labs, small networks, or anywhere you need instant visibility without the complexity of enterprise monitoring.

I built in network configuration so you can set the Pi to use either a static IP or DHCP without manually editing config files. This makes deployment quick, whether you need a fixed address or simply want to drop it into a network and get started.

Everything is managed through a web interface running on the Pi. Configure monitored hosts, adjust network settings, and tweak behavior from any browser on your local network. There's also a CLI for those who prefer the command line.

SysStat is designed for hobbyists, makers, and small-scale administrators who want a low-maintenance way to monitor network devices. Always-on, minimal hardware, gets the job done.

I took over the front-end development for an operational planning system for offshore industrial teams. Over three years, I evolved it from an early prototype into a mature, daily-use application and supported it through significant organizational change while keeping production stable.

The application enables teams to create, review, and approve daily plans. A key feature I designed was making the UI and workflows configurable through an admin interface, allowing non-developers to add tables, charts, tabs, and data connections without code changes—shifting routine changes from engineering to self-service for operations.

The system integrates with an enterprise data platform for storage and scheduled synchronization and supports a clear lifecycle from drafts to approved, auditable records. Stack: Django, Plotly Dash, and Flask.

Over time, I added operational hardening (monitoring, audit logging, and multi-environment deployments). I also released two supporting libraries adopted across the team: an open-source Python package for declarative time-series retrieval and a reusable UI component library used across related applications.

I led the technical development of a web-based economic analysis tool to evaluate project viability in the climate/industrial domain. Engineers and economists use the app to define scenarios with technical and financial inputs and compute a levelized unit-cost metric under discounted cash-flow assumptions.

I built the foundation and the Chrome: Django back end and models, dynamic input forms, Plotly/Dash visualizations, integration with an enterprise data platform, and Kubernetes deployment config. The calculations engine (DCF, NPV/IRR, levelized-cost solving) was built by domain specialists; I designed a clean serialization boundary so both layers could evolve independently.

The input workflow supports dozens of parameters via structured Django forms with validation and a draft/error flow—failed runs still save with actionable feedback so users can fix inputs and retry. Outputs include three views: KPI summary with breakdown charts, an annualized lifetime table, and a sensitivity analysis view.

My own product. A SaaS tool that gives Django teams a web dashboard for running, scheduling, and auditing management commands without SSH access to production servers.

The problem: Django management commands are powerful, but running them in production often requires SSH access, cron jobs with no visibility, or setting up Celery just to run a single command. ManageCommand replaces all of that with a pip install and a single line in settings.

Two parts. The runner is an open-source Python package that you install alongside your Django app. It connects outbound to the ManageCommand dashboard, syncs available commands, and polls for executions. The dashboard is the hosted web app where your team triggers commands, sets up schedules, and reviews execution history.

Security was the primary design constraint. The runner only makes outbound HTTPS connections, so you never open ports. Only explicitly allowlisted commands can run. No remote shell, no arbitrary code execution. Every execution is logged with user, time, arguments, output, and result.

I designed and built the whole thing: the runner package, the dashboard, the landing page, the documentation, the security model, and the go-to-market.

Custom Django admin interfaces for CareSolace, a mental health care platform. A question and answer tree editor using django-nested-inline with custom cross-level drag and drop on self-referencing hierarchies. A license matrix widget rendering hundreds of M2M relationships as a checkbox grid with check-all, clear-all, and copy tools for rows and columns. A versioned AI configuration system with YAML export/import, license validation, and regression test suites running 200+ cases via Celery with parallel runners and statistical scoring.

A Python/LLM tool that extracts structured data from scanned and photographed PDF documents published by Romanian forest districts. These are timber auction announcements with tabular data (lot numbers, species, volumes, prices). Still, every district uses its own format, and the PDFs are all photos or scans of physical papers with varying legibility.

The extraction runs as a multi-pass LLM pipeline. Pass 1 corrects page orientation. Pass 2 does raw transcription. Pass 3 extracts table structure. Pass 4 maps to a structured lot schema. Pass 5 re-renders uncertain values at 400 DPI for a targeted high-confidence re-read. Each pass saves intermediate artifacts for auditability.

This multi-pass design evolved because single-pass extraction proved prone to hallucinations. Each step narrows the problem, and cross-referencing between passes catches errors. Integration tests call the actual Claude API and compare against validated outputs, stable enough to work as a reliable regression suite.

Built for fore-sta.ro, a SaaS aggregating Romanian forestry data. Claude API is in production, with similar modules planned for other document types.