I build applications end to end, from the database schema to the interface. Most of the work is backend: REST APIs in Java and Node.js, relational data modelling, authentication and access control. The front-end and mobile work is usually there because the backend needed something in front of it.
I am in the final year of a master's in computer science and engineering at Ștefan cel Mare University in Suceava, after a bachelor's in computer engineering at the same university. I learn a stack by building something complete in it.
Potriv
Team allocation and skill matching
A web application for staffing projects with the people an organisation already has.
A web application for staffing projects with the people an organisation already has.
Problem
A project manager starting new work needs to know who has the skill, who is free, and who has done something similar before. Usually those answers are in a spreadsheet or in someone's head. Two people describe the same ability differently, so searching does not work, and when the answer is that nobody fits, that fact tends to disappear instead of being recorded.
Potriv is built around four things: a shared vocabulary for skills, a gap recorded as a fact, availability that comes from the people who own it, and a staffing decision with an owner and a record.
The product page. The illustration next to the headline is labelled "A worked example, not a screenshot", because at the time it was one.
What it does
An organisation holds departments, people, a skill catalogue and projects. A project states what it needs: team roles, how many of each, which technologies, over which dates. Team Finder ranks everyone against that.
What a project needs, before anyone is proposed. Proposed people are waiting on a department manager and do not reduce the open count, because somebody who might say yes is not somebody who has.
Each candidate's score breaks into three published parts: matched skills out of 60, past project matches out of 20, availability out of 20. A manager who disagrees with a ranking can see which part they disagree with.
Home. Counts and department sizes, scoped to what the signed-in user may see.The skill catalogue. One shared vocabulary, grouped by category.Access roles. Employee is the baseline nobody loses; the other three are granted.
The screenshots use seeded demo data in a scratch organisation, not real people. The seeder runs under an explicit profile and has a matching teardown.
Architecture
The backend is a modular monolith rather than microservices. Eight domain modules keep their own boundaries, so it can be split later without being distributed on day one.
Decisions
Security is layered and the admin console is limited on purpose. JWT gets you in, roles decide what you can call, tenant isolation decides whose rows you can reach. The admin console runs in its own session and cannot grant itself system admin, change credentials, or alter audit events.
The end-to-end suite walks the OpenAPI document rather than a hand-maintained list. It boots an isolated backend and exercises every operation three times: anonymous, wrong role, wrong tenant. A new endpoint without coverage fails the build on coverage drift.
Persistence is tested against a real PostgreSQL through Testcontainers. A mocked repository agrees with queries the database would reject.
Every pull request is gated on the full build and test suite, CodeQL and secret scanning, with a weekly dependency CVE scan.
What I would change
The scoring weights (60 skills, 20 past projects, 20 availability) are a guess. They have never been checked against a real staffing decision, and different organisations would weight them differently. Making them configurable is easy; validating them needs somebody's real staffing history first.
Onboarding also needs work. People join by invitation, which is right for a deployment and poor for evaluation: an empty workspace shows a setup checklist instead of the product. Writing the demo seeder is what made that obvious.
Statio
Survey data preparation and analysis
Master's dissertation. Importing, analysing and exporting multilingual survey data, with the uncertainty left visible.
Master's dissertation. Importing, analysing and exporting multilingual survey data, with the uncertainty left visible.
Problem
Survey data arrives messy and leaves overconfident. The messy part is import: columns that do not match the questions, rows that fail validation for a dozen reasons, and a second import that silently doubles the dataset. The overconfident part comes later, when a sentiment model produces a number and that number ends up in a paper as a measurement rather than a model's output.
Statio covers the whole path: import and clean responses, run analysis over a fixed snapshot, compare model output against human labels, export in the formats research tools read. The constraint throughout was that the platform may report what it measured and must not upgrade that into a conclusion.
Sign in. Organisations hold workspaces, workspaces hold surveys, with role-based access between them.
What it does
Responses arrive through a participation link or through CSV and JSON import. Import maps incoming columns onto questions, validates before writing, reports failures per row rather than rejecting the file, and de-duplicates so re-importing an export does not multiply records.
Analysis runs over an explicit snapshot rather than live data, so a result can be reproduced. Two engines run against that snapshot: a Random Forest classifier in Java and a transformer sentiment model. Model versions and dataset summaries are recorded with the run.
Workspace overview. The completion rate carries its own caption: not adjusted for data quality.Preparing a snapshot. Original responses stay unchanged and quality flags never remove anything on their own.
Keeping the output honest
The work that took the longest is not the model. It is what surrounds the model.
Quality flags carry their disclaimer in the product: a flag is a reason to review, not evidence that a response is invalid, and no suspicion probability is reported. Each flag shows the rule that fired and the value it measured.Blind human labelling. Model suggestions are withheld until the gold set is frozen. Two reviewers and a separate adjudicator, none of whom may be the curator, enforced server-side. The rubric names what does not justify a "review required" label: short answers, negative sentiment, rare vocabulary, disability, language proficiency, speed, or a model flag alone.
Human labels and model output are compared on the same items. When the underlying text changes, existing labels are invalidated rather than carried forward.
Running the two engines
Scoring and comparing are separate actions. Both engines score the same frozen set first; only a run where both completed on the same answers can be compared. The run survives leaving the page, because the server holds it.
On the synthetic demo survey, the engines scored 100 answers and agreed on 93.0% of them, Cohen's kappa 0.862. The product does not call that accuracy, and says why on screen: agreement is not accuracy, because both engines can be wrong in the same way. Gold metrics are computed only where human labels agree, describe only those answers, and carry no confidence interval. This run has no gold set at all, 100 answers unlabelled, so the accuracy panel reports that a labelled subset is required instead of printing a number.
Two engines over one frozen set, with a 3×3 confusion matrix. The disagreements: 5 answers the classical engine called neutral and the transformer called negative, 2 the classical called positive and the transformer called neutral. Figures from synthetic demo data.Cost, recorded next to agreement. The classical engine scored 100 answers in 443.5 ms, 4.4 ms each. The transformer took 18.89 s, 162.9 ms per answer at p50 and 322.3 ms at p95, batched seven ways. About 37 times slower per answer.The report states what it is: measurements, not conclusions. No narrative is generated here.Summarisation is opt-in and off by default. While it is off, no request leaves for the provider.
Where summaries are enabled, they are produced through an NVIDIA-hosted API from aggregated figures only, never from individual responses. Surveys support editions, so a later collection can be compared against an earlier one per engine rather than as one blended number. Exports cover JSON, CSV, XLSX, PDF and Jamovi.
Architecture
A Next.js web application sits in front of separate Auth, Dashboard and Analytics services as a backend-for-frontend, so the browser talks to one origin. Analytics is where Python and Java meet. PostgreSQL holds the data, Redis the transient work, everything ships as Docker images.
Decisions
Analysis runs against a snapshot, not live data. Without a frozen dataset two runs are not comparable and neither is reproducible. Model versions and dataset summaries are stored with each run for the same reason.
Import validates before writing and reports per row. A file failing on row 304 should say so, not refuse the other 749 rows. Re-importing is idempotent, because people re-import.
Labels are invalidated when their text changes rather than carried onto content they were never about.
The summarisation provider is off unless an admin enables it, and sees aggregated figures rather than individual responses.
Releases are pinned by digest rather than by tag, so what was verified and what is deployed are the same image.
Validation
Three results from three different runs. They are not one combined test of a single release.
Most recent comprehensive local run of Analytics: 516 tests, zero skipped.
Most recent Analytics main pipeline: 8 jobs succeeded, image published.
Previous five-image release: 184 API checks passed on Cloud Build.
Limits
The review index is not a calibrated probability, and not a lie detector or an AI-text detector. It ranks responses for human attention.
Scientific calibration is not complete, because there is no human gold dataset yet. The blind labelling workflow exists to produce one.
Real email delivery and end-to-end acceptance through Cloudflare are not finished.
The environment in these screenshots is a local development instance, not a production deployment.
The demo data is synthetic and labelled as such in the product. Checks against synthetic data say something about the software and nothing about research accuracy.
Desko
Desk booking and remote work management
A web application for organising office desks and remote work.
2026 – present · In development · Node.js 26, Express · PostgreSQL, Sequelize · argon2, jose, multer · node:test, Supertest, GitLab CI · 30 commits, 8 API resources, 2 CI stages · source
Desko organises office space and remote work in one place: buildings, offices and desks, desk bookings, and requests to work remotely. Managers and employees work from the same data instead of a shared spreadsheet.
It is in development. The backend API is the part that exists today; this page describes that part only.
What the API covers
Eight resources, each with its own controller and service: authentication, users, buildings, offices, desks, desk requests, remote-work requests and attachments. Controllers handle HTTP; services hold the rules; Sequelize models and migrations hold the schema.
Decisions
Passwords are hashed with argon2 and tokens are signed with jose, rather than rolling either by hand.
Uploads are checked by content, not by extension. An attachment is inspected with file-type before it is stored, so a renamed executable does not pass as a PDF. Storage sits behind its own module, so the local disk can be swapped for object storage later.
Errors are typed. Application errors, including conflicts, have their own classes, so a double booking comes back as a conflict instead of a generic failure.
Testing and CI
Tests cover services, middleware and full request flows through Supertest, using Node's built-in test runner. GitLab CI runs in two stages: format and lint checks first, then the migrations are applied to a real PostgreSQL 15 service and the suite runs against it. Nothing is mocked at the database layer.
What is missing
There is no front end yet, and nothing is deployed. The next step is the booking view for employees, then the manager's view over desk and remote-work requests.
One app for schedules, assignments, grades and announcements. I wrote the backend in Node and TypeScript over PostgreSQL: REST routes, services split by responsibility, input validation and error handling. Authentication is JWT, authorisation is role-based, and row-level security policies mean a student cannot reach another student's grades even if the API layer were wrong. The mobile client is React Native with offline storage, so a timetable is readable without signal.
91 endpoints over a 16-table schema at 85% test coverage, written alone. JWT with role-based access, BCrypt at cost factor 10, per-endpoint rate limiting with a five-attempt lockout, Flyway migrations, soft deletes through Hibernate, Stripe subscriptions with webhook handling that survives duplicate delivery, and separate Docker Compose profiles for development and production.
University timetabling as a constraint problem, solved with a genetic algorithm: fitness function, crossover and mutation operators written for this shape of conflict. The Vaadin interface meant the UI could be covered by TestBench integration tests in CI rather than being the untested part.
A bank and its ATMs as separate autonomous agents on the JADE platform, exchanging asynchronous ACL messages with JSON payloads. No shared memory and no central loop, so transactions have to come out correct when several agents act at once.
Built for a university course: Flask services, a React front end and 119 automated tests, running under Docker Compose. Written with Claude, GitHub Copilot and ChatGPT under one rule: nothing generated goes in until the test suite passes.
Hand landmarks from a live camera feed mapped to flight commands, flying a drone through a 3D environment. The hard part was not detection but mapping: a continuous, noisy hand position has to become a stable discrete command, or the drone shakes.
JavaScript
OLX Rent Tracker
2024 · JavaScript
Bot pentru monitorizarea anunțurilor de închiriere de pe OLX.ro. Primește notificări pe Telegram când apar apartamente noi care se potrivesc criteriilor tale.
Two Assist Tech Challenge programmes at Assist Software in Suceava, one month each, backend in 2024 and QA in 2023. Web development at Wind Medya in Istanbul, 2018 to 2019.
Education
MSc Computer Science and Engineering, Ștefan cel Mare University of Suceava, 2025 to 2027. BSc Computer Engineering, same university, 2021 to 2025. Meta Front-End Developer Professional Certificate, Coursera, 2023.
Languages
Turkish (native), Romanian (fluent), English (B2)
Suceava, Romania · mertaydogn0@gmail.com · +40 727 179 361 Open to backend, full-stack and mobile roles, on site in Romania or remote.