Engineer with a management degree
Management and Computer Science at LUISS Rome. The management half shows in how I work: written specifications, recorded decisions, measurable acceptance criteria — and I can read a P&L.
OPEN TO JUNIOR ROLES · RELOCATION OR REMOTE
$
Software engineer — backend, data & platform. CS + Management graduate from LUISS Guido Carli, Rome (Jul 2026). I build REST APIs in FastAPI, Node.js and ASP.NET Core, queue-driven workers with idempotency and retries, and Airflow/dbt pipelines gated by data-quality tests. Flip on Engineering mode for architecture diagrams and design decisions.
Executable value// executable_value
Four concrete reasons, not adjectives.
Management and Computer Science at LUISS Rome. The management half shows in how I work: written specifications, recorded decisions, measurable acceptance criteria — and I can read a P&L.
Idempotency keys, FOR UPDATE SKIP LOCKED queues, retries behind circuit breakers, a seeded deterministic rules engine with 146 regression tests passing. I build for the failure case first.
Airflow, PySpark and dbt for pipelines; R for econometric panel analysis; raw SQL with window functions and CTEs — plus KNIME and Power BI from a client-facing P&G team project.
Turkish citizen — no permit needed in Turkey. Italy: entitled to a 12-month post-graduation residence permit, convertible to a work permit with no employer quota wait. Open to relocation and remote, available now.
Proof of work// projects --all
Problem → solution → result. Every public repo is linked. Switch to Engineering mode for architecture, trade-offs and what broke along the way.
Backend · Distributed systems · Cloud
TypeScript/Node.js connectivity layer for EV chargers and vehicles — my largest system.
Problem. An energy platform sits in front of OEM APIs that time out, rate-limit and fail in ways the product above them must never notice. One flaky vendor cannot be allowed to degrade the whole platform — and a retried request must never start a car charging twice.
Solution. A connectivity layer built to isolate failure. Commands are written to a durable PostgreSQL queue with an idempotency key; workers claim rows using FOR UPDATE SKIP LOCKED so two workers never pick up the same command; every provider call is wrapped in retry plus circuit-breaker logic. Structured logs, Prometheus metrics and an SLO snapshot make failure visible, and a React operations dashboard shows device state, queue depth and SLO health. Backend tests run in GitHub Actions against a live PostgreSQL service container.
[React ops dashboard] [client / integrator]
\ /
v v
[Node.js API — TypeScript]
| enqueue command + idempotency-key
v
[PostgreSQL — devices + command_queue]
^ FOR UPDATE SKIP LOCKED
|
[Node.js worker pool]
| retry (exp. backoff) + circuit breaker
v
[Simulated OEM A] [Simulated OEM B]
observability: structured JSON logs · Prometheus metrics · SLO snapshot
infra: AWS CDK > CloudFormation > ECS/Fargate · RDS · CloudWatch alarms
Aug 2026 → present · Backend · Deterministic systems
Deterministic rules engine and game server for a multi-day, eight-player strategy game.
Problem. A strategy game played over several days by eight people lives or dies on trust: if a result is disputed, it has to be provable — and no client can be allowed to touch a balance, a deadline or an outcome.
Solution. A deterministic rules engine in C#: a seeded RNG means an entire season can be replayed exactly, so any disputed result is reproducible and auditable. The ASP.NET Core server owns time (a server-authoritative UTC clock) and money (a transfer ledger), so no client can alter a balance, a deadline or a result. A 146-case regression suite covers eight negotiation minigames, transfer rules, elimination boundaries and season-end conditions.
Data engineering · Orchestration
End-to-end batch pipeline: Airflow → PySpark → Parquet → PostgreSQL → dbt.
Problem. "I know SQL" and "I can build a data platform" are different claims. The second needs orchestration, a transformation engine, a warehouse, a modelling layer and tests that fail loudly when the data is wrong.
Solution. A reference pipeline that runs the whole loop: raw order events are validated, typed and deduplicated in PySpark, written as Parquet, loaded into a PostgreSQL warehouse, then modelled in dbt as a typed staging layer and a daily-sales fact table. The marts sit behind dbt data-quality tests, so a bad load fails the Airflow DAG instead of silently reaching a dashboard. Docker Compose reproduces everything locally with one command.
[data/raw/orders.csv]
| ingest
v
[PySpark — schema validation · typing · dedup]
| write
v
[Parquet — partition-friendly columnar]
| load
v
[PostgreSQL warehouse]
|
+-- dbt staging: stg_orders (typed, cleaned)
|
+-- dbt mart: fct_daily_sales + schema.yml tests
orchestration: Airflow DAG · env: Docker Compose · CI: GitHub Actions
open any card for the full case study
Swiss/EU job-market tracker — aggregates 200+ live listings from two APIs and ranks each 0–100 against my profile with TF-IDF cosine similarity.
Problem. Tracking junior roles across Swiss and EU boards by hand meant duplicates, stale posts and no way to rank fit.
Solution. Fetch from RemoteOK and Adzuna, normalise URLs to kill duplicates, score every posting against a candidate profile with TF-IDF + cosine similarity, and serve it all through a JWT-authenticated FastAPI backend in Docker.
[RemoteOK API] [Adzuna API]
\ /
[Ingestion — requests]
|
[Dedup — normalised URL hash]
|
[TF-IDF matrix] <──> [candidate profile]
| cosine similarity → 0–100
[SQLite] <── [FastAPI + JWT] <── client
A/B testing and difference-in-differences toolkit — power analysis, two-proportion z-tests, sample-ratio-mismatch detection and a two-way fixed-effects DiD estimator.
Problem. Most portfolio ML is prediction. The experimentation side — deciding whether a launch actually caused a metric to move — is usually skipped.
Solution. Power analysis to size a test, a two-proportion z-test with proper intervals, an SRM check that flags broken randomisation before anyone trusts a p-value, and a DiD estimator for when you can't randomise at all — the estimator family from my thesis.
Retrieval-augmented Q&A over regulatory PDFs — chunking, embeddings, FAISS semantic search, served via FastAPI and Streamlit with CI on every push.
Problem. Regulatory documents are long and dense; keyword search misses context entirely.
Solution. Ingest PDFs, chunk with overlap, embed into a FAISS index, retrieve the most relevant passages per query, and serve results over REST plus an interactive UI.
Cohort retention and funnel analysis in raw SQL — LAG, FIRST_VALUE, running totals, RANK vs DENSE_RANK — against a synthetic app-usage dataset.
Problem. "Compute N-week retention by cohort" and "rank X by Y, handling ties" are easy to get subtly wrong.
Solution. Analytical SQL with no ORM and no pandas standing in for what SQL should do: funnel conversion, weekly cohort retention, rolling averages and country rankings that show the RANK/DENSE_RANK difference on ties.
Store-level campaign optimisation for a P&G geo-targeted Oral-B campaign in Italy — predict which stores will respond and recommend the 2026 activation list.
Problem. The 2025 campaign had mixed results: some stores generated incremental sales, others none — budget was being spent where it didn't work.
Solution. Feature engineering on store data, logistic regression and random forest models to score each store's probability of success, a ranked activation list with an expected-profit "size of prize", and a Power BI dashboard with map-based exploration.
My part. Built the analytics workflow and trained the models in KNIME, supported evaluation (ROC/AUC, confusion matrix) and scoring, contributed to the final delivery.
Customer-churn classifier with a reproducible scikit-learn pipeline, served through a FastAPI endpoint and explored in a Streamlit dashboard.
Problem. A model in a notebook isn't useful to a business stakeholder — it needs to be queryable and visual.
Solution. A preprocessing + training Pipeline evaluated on accuracy, ROC-AUC and a confusion matrix, wrapped behind a prediction API, with a dashboard so a non-technical reviewer can explore predictions directly.
2–8 player co-op horror game in Unity 6 with Netcode for GameObjects — procedural depth-first-search mazes and host-authoritative multiplayer.
Problem. Real-time multiplayer needs every player to see the same maze, the same enemies and the same damage events.
Solution. The host generates an 18×18 DFS maze at session start and replicates it; NavMesh enemy AI, health and respawn state synchronise through NetworkObject state.
Server-rendered book catalogue with registration, login, guarded CRUD routes and image uploads — built by hand rather than leaning on the admin panel.
Problem. Prove an understanding of the request/response cycle without the framework's admin doing the work.
Solution. Hand-written models, views and templates; authentication guards on every write route; image upload handling.
Track record// git log --oneline
AUG 2026 → PRESENT
FEB 2026 → MAY 2026
SEP 2023 → JUL 2026
Empirical rigour// thesis.R
Econometric research on real EU data — the analytical foundation behind the engineering.
"Tourism Dependence and Regional Macroeconomic Resilience in Italy: The Economic Effects of the COVID-19 Shock"
Panel analysis of 21 Italian NUTS 2 regions over 2015–2024 using a continuous DiD framework with an event-study specification. Identified structural labour-market hysteresis as the mechanism behind persistent post-pandemic divergence in high-tourism regions. Supervisor: Prof. Diletta Topazio, LUISS Guido Carli.
β estimates the differential post-shock effect on tourism-dependent regions, with region (δ) and time (λ) fixed effects.
# Parallel pre-trends → sharp 2020 divergence → asymmetric recovery.
# Tourism-dependent regions never return to the counterfactual = structural hysteresis. Illustrative, reconstructed from the thesis findings.
REST paradigm// GET /api/resume
The CV, as a backend engineer would serve it.
{
"candidate": "Berke Tayfun Akseki",
"title": "Software Engineer — Backend, Data and Platform",
"education": {
"institution": "LUISS Guido Carli University, Rome",
"degree": "BSc Management and Computer Science (L-18)",
"graduated": "2026-07"
},
"stack": {
"languages": ["Python", "TypeScript", "JavaScript", "C#", "SQL", "R"],
"backend": ["FastAPI", "Node.js", "ASP.NET Core", "Django", "SQLAlchemy", "Pydantic"],
"data": ["PostgreSQL", "Airflow", "PySpark", "dbt", "Parquet", "Pandas"],
"ml_stats": ["scikit-learn", "statsmodels", "SciPy", "FAISS", "Power BI"],
"cloud_devops": ["Docker", "AWS (ECS/Fargate, RDS, CDK)", "GitHub Actions", "Prometheus", "Grafana"]
},
"experience": [
{ "role": "Project PARCA — rules engine & game server", "since": "2026-08" },
{ "role": "Creative Manager Intern, LUISS Language Cafe", "from": "2026-02", "to": "2026-05" }
],
"languages_spoken": { "tr": "native", "en": "C1", "fr": "B2", "it": "B1" },
"work_authorisation": {
"TR": "citizen — no permit required",
"IT": "12-month post-graduation permit, convertible to work permit"
},
"location": "İzmir, Turkey — open to relocation and remote",
"public_projects": 9,
"available": true
}
Try it on me// match(jd, me)
Keyword matching in the spirit of my Jobscope project: it checks the job description against my real stack and shows what lines up and what doesn't. It runs entirely in your browser — nothing you paste leaves this page.
// in my stack
// not in my stack (yet)
Score = share of recognised tech mentions in the JD that I've shipped with. Ranking real listings with TF-IDF lives in jobscope.
Get in touch// open_socket()
Looking for junior backend, data or platform roles — relocation or remote. If you're hiring, I'd love to talk.
arrow keys / WASD / swipe to move · eat the ● · esc to exit