Open to part-time roles alongside my studies, in Prague or hybrid

Hey, I’m Tobiáš Building reliable software, data pipelines and useful automation.

I'm a student at VŠE in Prague who works with Python, SQL and application code to turn raw data and practical problems into systems that run: ingestion pipelines, database-backed applications and the scripts that connect them.

The path most of my projects follow, and the tools I use along it.
  1. collect
    • Excel and CSV
    • REST API
    • Email and PDF
  2. transform
    • Python
    • Pandas
    • Validation
  3. store
    • PostgreSQL
    • MySQL
    • SQLite
  4. serve
    • Flask
    • API
    • Web interfaces

Selected projects

Each one covers the whole path: where the data comes from, how it is checked and stored, and how people end up using it.

TS Financial Intelligence

Market, macro and housing data platform

In active development

  • Python
  • FastAPI
  • SQLAlchemy
  • Alembic
  • PostgreSQL
  • SQLite
  • NumPy
  • React
  • TypeScript
  • pytest
  • Playwright

A research terminal that collects market prices, official statistics, central-bank releases and Czech housing data from more than fifteen sources into one database, then serves it through a FastAPI backend and a React interface. Every figure keeps its source, date and freshness.

Market overview dashboard: a one-year performance chart of the S&P 500, Nasdaq 100, Euro Stoxx 50, Bitcoin and Brent rebased to 100, a watchlist, and a snapshot of indices, stocks, crypto, commodities, currencies and bond yields priced in Czech koruna.
  1. sources
    • Public APIs
    • CSV and SDMX
    • RSS feeds
  2. adapters
    • Normalised records
    • Rate limiting
  3. validation
    • Duplicates
    • Future dates
    • Invalid values
  4. storage
    • SQLAlchemy
    • Alembic
    • SQLite or PostgreSQL
  5. serving
    • FastAPI services
    • React + TypeScript
Each provider runs in its own transaction. A failed run rolls back, keeps the last good data and records the error, so one broken source never empties a chart.

What I built

Market prices, macroeconomic statistics and housing data live in many places with different formats, schedules and licences. Comparing them means reconciling units, dates and currencies by hand, and it is easy to lose track of where a number came from or whether it is still current.

  • Provider adapters for public sources including ČNB, ECB, US Treasury, Bundesbank, FRED, Eurostat, ČSÚ, SEC EDGAR, the Prague Stock Exchange and CoinGecko, plus keyed sources such as Twelve Data and ČNB ARAD.
  • An ingestion pipeline that validates each batch before storing it and logs every run.
  • Analytics for comparing up to eight instruments: rebased performance, risk statistics, rolling correlation and same-day currency conversion.
  • Czech real-estate views: regional price statistics, ARAD housing-loan data, Realitní pes listing search and an investment calculator.
  • Google OAuth accounts with per-user watchlists, saved comparisons and research notes.

Engineering decisions

Provenance on every number
Each series carries its source, observation date, retrieval time and a staleness flag computed from its update cadence. The interface shows them next to the figure.
Validation before persistence
Duplicates, future dates, non-finite values, non-positive prices and high-below-low bars are rejected and counted by reason before anything reaches the database.
Quota-aware on-demand requests
Property listings come from an API with a small monthly quota, so they are fetched only on request, cached, deduplicated with a per-key lock and retried with bounded backoff.
Tests that never call the network
Provider parsers are tested against recorded responses. CI runs the backend suite on both SQLite and PostgreSQL, then type-checks, lints, tests and builds the frontend.

In the repository 150 backend tests, 7 Alembic migrations and a GitHub Actions workflow covering ruff, pytest on SQLite and PostgreSQL, TypeScript, ESLint, Vitest and a production build.

A research and learning tool. It does not provide investment advice.

ITG Lunch App

School canteen system with RFID card scanning

Maturita project, 2026

  • Vue 3
  • Vite
  • Vue Router
  • Socket.IO
  • Firebase Auth
  • Node.js
  • Express
  • Python
  • pyscard
  • Flask
  • SQLite

A web app for serving lunches at 1. IT Gymnázium, started under the working name Luncheroo. Students see their lunch for the day, gift it to a classmate or donate it to a shared pool. Canteen staff serve lunches by tapping a student’s ISIC card on an RFID reader. Built with a classmate: my maturita thesis covers the Vue 3 frontend and the card-reader integration.

Student dashboard of the lunch app: a welcome header, today's lunch status showing no order, and quick actions to gift a lunch or browse the public lunch pool.
  1. card
    • ISIC card
    • ACR122U
    • Raspberry Pi
  2. bridge
    • Python reader client
    • Node.js + Socket.IO
  3. interface
    • Vue 3
    • Card scanner screen
  4. backend
    • Flask REST API
    • JWT
  5. storage
    • Flask-SQLAlchemy
    • SQLite
The backend checks that the card belongs to a student who has a lunch today that has not been served yet, records it, and pushes the change to every open screen over Socket.IO. The day’s orders arrive as a PDF that the backend parses.

What I built

Lunches were served from a printed list: each student had to find their name, tick it off and tell the cook their meal. It was slow at peak time, names got mixed up, and a prepaid lunch was simply wasted when its owner was absent.

  • The Vue 3 frontend: a student dashboard, gifting a lunch to another student, and a public pool for donating and claiming lunches.
  • Admin screens for the canteen: a live card scanner, assigning ISIC cards to students, user management and daily statistics.
  • The card-reader bridge: a Python client reads the card UID from an ACR122U reader and a small Node.js server broadcasts it to the app over Socket.IO.
  • Google sign-in through Firebase, exchanged for the app’s own JWT, with router guards that keep admin screens behind the admin role.

Engineering decisions

REST for actions, Socket.IO for live state
Sign-in, gifting and card assignment go through REST endpoints. Scans, lunch counts and the public pool update over WebSockets, so every screen in the canteen stays current.
The reader bridge only forwards
The card-reader server just broadcasts the UID it reads. Every check happens on the backend, so the hardware side holds no rules that could drift out of sync.
Feedback built for a queue
The scanner shows exactly one of four states, each with its own colour and icon: waiting, served, warning (unknown card or no lunch) or error. After a successful scan it resets on its own, ready for the next card.

In the repository Submitted as my maturita thesis at 1. IT Gymnázium in 2026 and tested with a real ACR122U reader.

Campusello

Student budgeting app

In active development

  • Python
  • FastAPI
  • SQLAlchemy
  • SQLite
  • Vue 3
  • TypeScript
  • Pinia
  • Tailwind CSS
  • Web Push

A Czech-language budgeting app for students. It tracks card and cash spending, category budgets, savings goals and recurring bills, and works out how much you can spend today. Vue 3 client, FastAPI API, installable on a phone as a PWA. Existing solutions were not cutting it for me. So I made my own.

Campusello dashboard in Czech: total wallet balance split into accounts, a daily spending limit with the formula behind it, a forecast of whether the money lasts until payday, and daily budgets by category.
  1. client
    • Vue 3
    • Pinia
    • PWA
  2. api
    • FastAPI
    • Pydantic schemas
  3. rules
    • Daily limit
    • Wallet balances
  4. storage
    • SQLAlchemy
    • SQLite
  5. notifications
    • Web Push
The daily limit is the wallet balance minus recurring bills not yet paid this month, divided by the remaining days including today.

What I built

Student money is small and irregular... trust me, I would know. A monthly total does not tell you whether you can afford something today once rent and subscriptions still have to come out.

  • Transactions with categories across separate card and cash wallets.
  • Category budgets, savings goals and recurring bills.
  • A daily spending limit based on what is left after unpaid bills.
  • Reports, plus CSV and JSON export of all transactions.
  • Web push reminders for recurring bills, and the EUR rate from ČNB.
  • Google sign-in and email accounts with Argon2 password hashing and JWT.

Engineering decisions

Balances that stay consistent
Editing or deleting a transaction adjusts the matching card or cash balance by the net difference, instead of recalculating from scratch.
Data scoped to each account
Transactions, budgets, wallets, bills and profiles belong to the signed-in user. Registration can be limited to an allow-list of email addresses.
Careful file uploads
Profile photos are decoded with Pillow with decompression-bomb checks before they are stored.

In the repository Includes a Render blueprint that deploys the API with persistent storage and the static client.

Portrait of Tobiáš Svášek

About me

I study Finance at the Faculty of Finance and Accounting of the Prague University of Economics and Business (VŠE), and I learn engineering mostly by building. My projects usually start with a practical question and end up touching every layer: pulling data from an outside source, cleaning it, storing it in a schema that holds up, and putting an interface or an export on top.

  1. VŠE, Prague Finance at the Faculty of Finance and Accounting
  2. Maturita 2026 a school lunch app with ISIC card scanning
  3. 15+ data sources from ČNB and ECB to Eurostat, in one database
  4. 150 backend tests in TS Financial Intelligence

That is what draws me to data engineering. I want to know where a number came from, what happened to it on the way, and what the system should do when a source fails. I'm looking to do that work in a team that runs real pipelines, and to learn how it is done at a larger scale.

What I work with

Grouped by what I use them for. The first line in each group is what I work with most; the second is what I have used in projects and can talk through.

Data and databases

Schemas, queries and transformations behind every project here, from SQLite prototypes to PostgreSQL in CI.

  • SQL
  • PostgreSQL
  • SQLAlchemy
  • Pandas
  • Data processing and transformation

Also used MySQL, SQLite, Alembic migrations

Programming

Python for backends, pipelines and scripts. JavaScript and TypeScript for interfaces.

  • Python
  • SQL
  • JavaScript

Also used TypeScript, C#, PHP, HTML and CSS

Backend and applications

Database-backed web applications with authentication and external integrations.

  • Flask
  • FastAPI
  • REST APIs and integrations
  • Authentication (Google OAuth, JWT)

Also used .NET, React, Vue

Automation and tooling

Scripts that move data between systems so nobody has to do it by hand.

  • Python scripting
  • Email and PDF processing
  • Data import and export

Also used Scheduled jobs, Linux and the command line, Git and CI

Hiring for a data, Python or backend internship? Or just looking for someone eager to create? I'd like to hear about it.