Josip Arambašić
HR

Open to junior roles

Junior Software DeveloperPodstrana (Split), Croatia

Josip Arambašić

I build reliable backends and the web apps on top of them.

Master’s graduate in Computing from FESB, Split. I design layered APIs, model relational data and test the parts that tend to break. For my Master’s thesis I connected a vision-language model to a Symfony application.

  • Backend development
  • Full-stack web apps
  • AI integration
View projectsDownload CVContact me
Josip Arambašić
MSc Computing · FESB · 2026

About me

I studied Computing at FESB in Split: a Bachelor’s degree (2020–2024) followed by a Master’s (2024–2026). My Bachelor’s thesis was about data visualisation in R; for my Master’s thesis I built a Symfony system that generates image descriptions using vision-language model APIs.

For seven years I also worked as a head waiter at Le Méridien Lav, alongside my studies. Running a restaurant full of guests taught me to stay calm under pressure, organise a team of colleagues and get the job done properly the first time. I bring the same habits to software: understand the problem first, keep things simple, and check my own work before someone else has to.

Outside coursework I keep building real projects: a booking platform for a tyre service, a FastAPI middleware service and a QA-focused banking demo. I am also building two websites for real clients, which are currently in progress.

Currently learning

  • AI engineering: building applications on top of LLM APIs
  • Modern Python (typing, async, current tooling)

What I am looking for

A junior backend, full-stack or AI-focused developer role on a team where I can ship real features, learn from code review and grow into owning parts of the system.

Josip Arambašić holding his bound Master’s thesis, standing with three people in front of the projected title slide at FESB
After defending my Master’s thesis at FESB, 2026

Featured projects

Projects I designed and built end to end: what problem each one solves, how, and what it taught me.

01Full-stack · Largest project

Web Mechanic: Tyre Service Booking Platform

A complete business system for a tyre service: public website with online booking, plus separate portals for customers, mechanics, warehouse staff and administrators.

Problem
A booking system fails in the edge cases: two customers grabbing the same slot, stock being reserved twice, or one user reading another user’s data.
Solution
A Spring Boot modular monolith (auth, appointments, inventory, reservations, admin) where each module exposes a single facade. Double bookings are blocked in PostgreSQL with an EXCLUDE constraint, stock changes only through conditional updates with a full movement log, and ownership checks live inside the queries themselves.
What I learned
Put important guarantees where they cannot be forgotten, in the database and in the query, and prove them with tests that run against real PostgreSQL, not an in-memory substitute.
  • 44 backend integration tests: concurrent booking, cancellation, stock races, IDOR and privilege escalation
  • Module boundaries enforced with ArchUnit
  • Frontend covered by Vitest, Playwright end-to-end tests and automated accessibility checks (axe-core, WCAG 2.1 AA)
  • Java
  • Spring Boot
  • Spring Security
  • PostgreSQL
  • Flyway
  • React
  • TypeScript
  • Tailwind CSS
  • Docker
Source code

02Backend · AI · Master’s thesis

AI-Powered Content Management System

Users upload an image; a vision-language model (Anthropic Claude) generates a semantic description in the background, and the app measures how API latency behaves.

Problem
Calls to an AI model take several seconds and sometimes fail. Doing them inside a web request makes the app slow and fragile.
Solution
A layered Symfony app (controller → service → repository) with JWT authentication and per-user data isolation. Uploads dispatch a message to a Symfony Messenger queue; a background worker calls Claude, retries transient errors with exponential backoff, and stores the result together with latency and image size for analysis.
What I learned
How to treat an external AI API as an unreliable dependency: keep it off the request path, separate transient from permanent errors, make processing idempotent, and measure instead of guessing.
  • Asynchronous processing with Symfony Messenger (queue + worker)
  • Latency statistics: average, min/max, correlation with image size
  • Modern PHP 8 (attributes, enums, constructor promotion); Docker + GitHub Actions CI
  • PHP 8
  • Symfony 6.4
  • Doctrine ORM
  • Symfony Messenger
  • MySQL
  • JWT
  • Twig
  • Claude API
Source code

03Backend · Python

TicketHub: Support Ticket Middleware

A FastAPI service that pulls support tickets from an external source, stores them locally and exposes a clean, authenticated REST API.

Problem
Depending on a live third-party API for every read makes a service slow and unavailable whenever the source is down.
Solution
All reads and writes go to a local database. Data from DummyJSON is transformed into a standard ticket model (title, status, priority, assignee, raw JSON) and kept fresh with a dialect-aware upsert sync that never overwrites local changes.
What I learned
Async SQLAlchemy and Alembic migrations in practice, and how small decisions like caching, rate limiting and a CI pipeline make a service feel production-ready.
  • 33 pytest tests (unit + integration, no network calls)
  • JWT-protected write endpoints, rate limiting, cached statistics
  • CI on every push: ruff → migrations → pytest; Docker Compose setup
  • Python 3.11
  • FastAPI
  • SQLAlchemy (async)
  • Alembic
  • Pydantic
  • Pytest
  • Docker
  • GitHub Actions
Source codeAPI docs
Screenshot of the mobile banking activation demo

04Backend · Testing

Mobile Banking Activation & QA

A simulation of how a banking app activates a new device with a one-time code. I built it to practise the full QA lifecycle, not just the code.

Problem
Activation codes have strict rules: six digits, valid for five minutes, single use, tied to one user, blocked after five wrong attempts. Each rule is a place for bugs.
Solution
A FastAPI service (router → service → database) with Pydantic validation, a small HTML/JS frontend, and complete QA documentation: test cases, bug reports and a test report.
What I learned
The value of tracing a requirement all the way to a regression test. The five-minute expiry rule led me to a real timezone bug, which is now covered by an automated test.
  • 22 automated pytest tests: positive, negative and edge cases
  • 19 documented manual test cases and 3 bug reports
  • Swagger/OpenAPI documentation
  • Python
  • FastAPI
  • Pydantic
  • SQLAlchemy
  • SQLite
  • Pytest
  • HTML/CSS/JS
Source codeLive demo

Client demos in progress

Websites I am building for real clients. They are live as previews while I wait for final photos and content.

Technical skills

Grouped by how I have actually used them. “Used in projects” means I have shipped working code with it; “Familiar” means I have worked with it but would still ramp up.

Languages

  • PHP
  • Python
  • Java
  • TypeScript
  • JavaScript
  • SQL
  • C#
  • R
  • C

Backend

  • Symfony
  • Spring Boot
  • FastAPI
  • REST API design
  • Doctrine ORM
  • SQLAlchemy
  • JWT authentication
  • Message queues (Symfony Messenger)
  • ASP.NET Core

Frontend

  • React
  • HTML & CSS
  • Tailwind CSS
  • Twig
  • Next.js

Databases

  • PostgreSQL
  • MySQL / MariaDB
  • SQLite
  • Migrations (Flyway, Alembic, Doctrine)

Testing & quality

  • Pytest
  • Integration tests (Spring Boot)
  • Vitest
  • Playwright
  • Manual test cases & bug reports

DevOps & tools

  • Git
  • Docker
  • GitHub Actions
  • Vercel
  • VS Code
  • PhpStorm
  • Visual Studio

AI

  • Claude API (vision-language models)
  • Async processing of model calls
  • Latency measurement

My approach

  1. Problem-solving

    I start by writing down what can go wrong, such as double bookings, slow external APIs or users seeing each other’s data, and design around those cases first.

  2. Architecture

    Layered and modular, as simple as the problem allows. Clear boundaries (controller → service → repository, one facade per module) keep code easy to change.

  3. Development

    Small, readable steps with Git, environment-based configuration, Docker for a reproducible setup, and a README that lets someone else run the project.

  4. Testing

    I test the things that actually break: concurrency, permissions, edge cases. Tests run in CI on every push, and against a real database when the guarantees depend on it.

  5. Learning

    I learn a new technology by building something real with it, reading the official docs, and comparing my result with how experienced developers solve the same problem.

Experience & education

Education

  1. 09/2024 – 09/2026

    Master’s Degree in Computing

    FESB, Faculty of Electrical Engineering, Mechanical Engineering and Naval Architecture, Split

    Thesis: An image description generation system based on the Symfony framework and VLM APIs

  2. 09/2020 – 06/2024

    Bachelor’s Degree in Computing

    FESB, Faculty of Electrical Engineering, Mechanical Engineering and Naval Architecture, Split

    Thesis: Data visualisation using the R programming language

Work experience

  1. 06/2019 – 06/2026

    Head Waiter · Full-time

    Le Méridien Lav · Podstrana, Croatia

    • Managed daily operations and coordinated staff in a high-volume hospitality environment.
    • Organised team schedules and led daily activities while keeping guest satisfaction high.
    • Handled inventory control and on-the-spot problem-solving under pressure.

  2. 06/2018 – 08/2018

    Warehouse Worker

    Disa d.o.o. · Split, Croatia

    • Supported warehouse operations: goods handling, stock organisation and order preparation.

Languages

  • CroatianNative
  • EnglishB2 (CEFR, all skills)

Let’s talk

I am looking for a junior backend, full-stack or AI-focused developer role. Email is the best way to reach me.

Podstrana (Split), Croatia