Jan Saklak
Backend Developer
4+ years exp
10+ projects
C++
Python
SQL
JavaScript
C
Node JS
Java
Kotlin
MATLAB
C#
Active 9 days ago
+48 (697) 750457 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Fullstack web developer (middle) focused on React frontends and simple Node/Express backends. The strongest proven skill is building tested React component flows and a contextual cart implementation, evidenced by src/__tests__/components.test.js validating CartContext and the cart/payment components. There is little evidence of advanced performance engineering, request cancellation/optimistic-update patterns, or production-grade deployment/CI artifacts.
Technical skills
C++
Python
SQL
JavaScript
C
Node JS• Middle
Java• Junior • 4y+ • 10+ projects
Kotlin• Junior • 3 projects
MATLAB• Junior
C#• Middle
C++
CMake
Python
Asyncio
C
MPI
Node JS
Express
Bcrypt
Passport.js
C#
.NET
WPF
Databases
PostgreSQL
SQLite• 3y+ • 3 projects
MySQL• 3y+ • 3 projects
Frontend
D3.js
React.js
React Router
DevOps
CI/CD
Docker
Git
GitHub Actions
Rest API
AI/ML
Claude
Copilot
NumPy
OpenMP
Prompt Engineering
Timeline
EEG Researcher
•
Middle
ERPinatorLab & Cognitive Neuroscience Laboratory, Jagiellonian University
•
Full-Time
Analyze complex neurophysiological datasets using MATLAB-based signal processing workflows and EEGLAB. Manage and structure large experimental datasets with focus on data integrity and storage optimization. Operate BioSemi EEG equipment and support troubleshooting of technical setups during experiments.
MATLAB
EEGLAB
Tram Simulator
Desktop app
Multi-platform simulation of trams written in Flutter
Flutter
Dart
Python
Terminal emulator
Desktop app
Jagiellonian University
Master's Degree •
Applied Computer Science
Jagiellonian University
Bachelor's Degree •
Cognitive Science
Jagiellonian University
Bachelor's Degree •
Applied Computer Science
Middle Backend Developer
Confidence: Medium API Engineer
Full-stack generalist (C# desktop + Node.js) at a middle level with a strength for building modular single-node applications and game/domain logic. The strongest proven skill is building modular C# application logic with persistence and error handling as shown in GalaxyGame/Game.cs and GalaxyGame/JsonManager.cs. The public code lacks evidence of production-grade backend practices such as schema migrations, secrets management, structured observability, and scalable deployment patterns.
API Design
3/10
How well APIs are designed
Basic REST-style API structure and route handlers are present but lack versioning, consistent error contract, pagination, idempotency keys or documented API contracts; evidence shows conventional CRUD handlers without advanced API design decisions.
Data Layer & Database
3/10
Working with databases
Data layer uses SQLite with schema creation and parameterized queries, but there is no migration history, transaction management, or explicit handling of schema evolution.
Scalability & Performance
1/10
Handling load and speed
Little evidence of scalability or performance engineering; single-process Express with SQLite, no caching, no queueing or connection pooling, and no measured optimizations.
System Architecture
3/10
Overall system structure
Reasonable module separation for small apps (controllers/models, UI vs domain logic) and multiple projects (game, task graph, Node app), but no evidence of deliberate distributed architecture, service contracts, or production config/secret management.
Security & Auth
2/10
Protecting data and access
Some basic security awareness (parameterized SQL) but several weak spots for production (hard-coded session secret, minimal input validation shown, no token lifecycle or secret management), and authentication pieces appear in boilerplate code rather than in audited core files.
Reliability & Observability
3/10
Stability and monitoring
Basic reliability and observability practices are present: unit tests for the TaskGraph, defensive error handling in game persistence and JSON deserialization, and console logging; no structured logging, metrics, retry/backoff, or graceful shutdown patterns for services.
Expertise
.NET• Middle
Node.js• Middle
Industries
Gaming• Middle
Media & Entertainment• Middle
Technologies
C#• Middle
Node JS• Middle
.NET
Express
Bcrypt
SQLite• 3y+ • 3 projects
WPF
Passport.js
Recommendations
- Develop single-node REST APIs and small internal services (Express + SQLite or Postgres) where CRUD and simple auth are sufficient.
- Build and extend C# WPF desktop tools and game logic that require clean domain modeling and local persistence.
- Harden Node services for production: add migrations, secrets management, input validation, and structured logging/metrics.
- Add integration tests and CI pipelines to improve reliability and demonstrate operational readiness.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Frontend Developer
Confidence: Medium Fullstack
Fullstack web developer (middle) focused on React frontends and simple Node/Express backends. The strongest proven skill is building tested React component flows and a contextual cart implementation, evidenced by src/__tests__/components.test.js validating CartContext and the cart/payment components. There is little evidence of advanced performance engineering, request cancellation/optimistic-update patterns, or production-grade deployment/CI artifacts.
UI Component Architecture
4/10
How interface parts are built
Component-based React structure with a centralized CartContext shows deliberate composition and avoids prop-drilling, but there is no custom design system or advanced component library work.
Evidence
jansaklak/projektowanie_obiektowe/Zadanie8/e-commerce-project/frontend/src/contexts/CartContext.js
jansaklak/projektowanie_obiektowe/Zadanie8/e-commerce-project/frontend/src/components/Products.js
jansaklak/projektowanie_obiektowe/Zadanie8/e-commerce-project/frontend/src/__tests__/components.test.js
Responsive & Cross-browser
4/10
Works on all screens and browsers
Layouts use CSS Grid with auto-fill/minmax and media queries for narrow screens, showing practical responsive choices, but there is no explicit cross-browser feature detection or RTL/i18n readiness.
Performance Optimization
1/10
Speed of the interface
Little to no explicit performance engineering: no code-splitting, no measured before/after artifacts, and no virtualization; styling is tidy but not performance-driven.
Accessibility & Semantics
4/10
Usable for everyone
Accessible form semantics are present (labels with htmlFor and tests using getByLabelText), and controls expose disabled states, but there is no advanced focus management or ARIA on custom widgets.
State Management & Data Flow
3/10
Managing data in the app
Server and client state flows are implemented correctly for typical CRUD and cart scenarios with contextual state and tested edge cases, but there is no request cancellation, optimistic updates with rollback, or state machines for complex flows.
Evidence
UX & Visual Polish
4/10
Look and feel quality
UX covers common edge states (loading, error, empty, success), includes meaningful micro-interactions in CSS and clear user flows, but lacks advanced perceived-performance patterns like skeleton loaders or optimistic UI.
Verified artifacts
Expertise
React• Middle
HTML & CSS• Middle
Industries
Commerce• Middle
Media & Entertainment• Middle
Technologies
D3.js
React.js
React Router
Recommendations
- Build and extend small to medium e-commerce SPAs: implement product lists, cart flows, checkout and integrate with backend APIs.
- Harden frontend async flows: add request cancellation, optimistic updates with rollback, and centralized error handling in CartContext or custom hooks.
- Add targeted performance work: code-splitting, bundle analysis, and skeleton loaders for key routes to improve perceived performance.
- Expand backend skills by replacing SQLite with a production-ready DB and adding tests and API versioning for the Node/Express services.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Game Developer
Confidence: Medium Generalist
C#/.NET tooling developer (middle level) specializing in scheduling and visualization tools for task graphs. The strongest proven skill is building WPF-based scheduling and visualization tooling, evidenced by the drawing and UI update logic in MainWindow.xaml.cs and the assignment and scheduling algorithms in Tasks/Tasks.cs. There is little to no evidence of performance engineering (profiling or zero-alloc hot paths), advanced rendering or deterministic simulation in public code.
Gameplay Systems & Mechanics
3/10
How game logic works
Solid implementation of scheduling and assignment algorithms for task graphs (assignment heuristics, compound tasks, basic task distribution) with unit tests, but no advanced algorithmic complexity or formal evaluation.
Evidence
TaskGraph/Tasks/Tasks.cs: CostList.AssignEachToFastestWorker
TaskGraph/Tasks/Tasks.cs: CostList.AssignToCheapestWorker
TaskGraph/Tasks/Tasks.cs: CostList.AddRandomCompoundTask
Graphics & Rendering
2/10
Drawing game visuals
Custom visualization using WPF drawing primitives for nodes, edges and layout logic; no custom GPU work or render-pipeline engineering.
Evidence
TaskGraph/Tasks/MainWindow.xaml.cs: DrawAssignmentGraph (drawing nodes, lines, labels on Canvas)
TaskGraph/Tasks/TaskAssignmentWindow.xaml.cs: DrawAssignmentGraph (Canvas-based UI rendering)
Physics & Math
3/10
Game physics and math
Basic graph algorithms and traversal are implemented correctly (BFS, DFS and path enumeration) and there is numeric handling for times/costs; lacks spatial partitioning, advanced integrators or deterministic simulation.
Evidence
TaskGraph/Tasks/Tasks.cs: Graf.BFS
TaskGraph/Tasks/Tasks.cs: Graf.DFS and DFSUtil
TaskGraph/Tasks/Tasks.cs: Times.SetRandomTimesAndCosts (time/cost aggregation logic)
Engine Proficiency
3/10
Skill with the game engine
Practical use of desktop application frameworks and UI threading patterns (WPF, Dispatcher, async Task.Run) and basic data model separation; not extensive custom engine or editor toolchain work.
Evidence
TaskGraph/Tasks/MainWindow.xaml.cs: UpdateUIAsync uses Task.Run and Dispatcher to update UI
TaskGraph/Tasks/MainWindow.xaml.cs: uses OpenFileDialog/SaveFileDialog and binds data to TaskGrid
Performance & Frame Budget
1/10
Keeping the game smooth
Minimal explicit performance work: background task offloading is used to avoid blocking the UI, but there are no profiler numbers, pooling, zero-alloc hot-path work or other frame-budget optimizations.
Evidence
TaskGraph/Tasks/MainWindow.xaml.cs: UpdateUIAsync uses Task.Run to run assignment algorithms off the UI thread
Content Pipeline & Tooling
3/10
Tools for game content
Basic content pipeline features are present: file parsing, import/export, and unit tests for core functionality, enabling reproducible test runs and simple export workflows.
Evidence
TaskGraph/Tasks/Tasks.cs: CostList.LoadFromFile (text format parsing and validation)
TaskGraph/Tasks/Tasks.cs: PrintALL (export to text) and PrintAssignments
TaskGraph/Tasks.UnitTest/CostListTest.cs: unit tests for assignment and compound task functionality
Expertise
Game Development Tools & Pipeline• Junior
Industries
Software• Junior
Technologies
JavaScript
C
MPI
Recommendations
- Develop desktop or internal tooling for task scheduling, resource planning and visualization (WPF or Electron ports) where the existing assignment heuristics and file import/export are useful.
- Implement performance and scalability improvements for large graphs: add profiler captures, object pooling, and lower-allocation hot paths for assignment algorithms.
- Extend the simulation with deterministic timestep control, benchmarking harnesses and reproducible seeds to support evaluation of scheduling strategies.
- Add richer editor tooling and data-driven configuration (Scriptable-like assets or JSON schema) and automated tests/CI to increase reliability for pipeline use.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: