Konstantin Georgiev

Backend · Junior · Sofia, Bulgaria · UTC+02:00 · Partially remote · Work permits: Bulgaria

Fullstack

TypeScript

JavaScript

SQL

Rust

Node JS

API Design: 5/10

Security & Auth: 5/10

Data Layer & Database: 4/10

Active 1 day ago

Download CVCV

Overview

Technical skills

Projects

Roles

Overview

A frontend-focused app engineer (middle level) who builds local-first desktop UI with careful TypeScript and CSS craftsmanship. The strongest proven skill is building a polished, local-first notes UX and safe Markdown conversion as evidenced by Notes/src/lib.ts (Tauri/localStorage backend abstraction, save/restore) together with Notes/src/markdown.ts (marked + DOMPurify + Turndown usage). There is limited evidence of complex async state management, automated tests, server-state patterns, or advanced performance instrumentation in the publicly visible code.

Phone

Technical skills

Languages

TypeScript

JavaScript

SQL

Rust

Node JS

Frontend

React.js

Next.js

Tailwind CSS

Vite

DevOps

GitHub

Rest API

Git

Other

Serde

Playwright

PostgreSQL

Tokio

Electron

Vitest

Supabase

PostCSS

Frontend

Projects

Arg Electric

Company website for an electrical installation business featuring services, process overview, gallery, and contact information. Built with a TypeScript/JavaScript and Tailwind CSS frontend approach. Intended to present company details and help users reach the business.

Multi-Agentic-Terminal

Electron-based desktop application that presents multiple terminal sessions within a single window. Designed to switch and manage terminal tabs/sessions in one interface. Implemented with JavaScript and Electron.

Notes Desktop

Desktop notes application that stores notes locally as Markdown files. Built as an Electron app with TypeScript to provide a lightweight authoring experience. Intended for offline personal note keeping and quick retrieval.

KG Scripts

Web agency project delivering custom website builds from scratch with a focus on performance and SEO. Includes a client-facing admin panel for managing website content. After launch, it supports ongoing maintenance and adds new features using a React/Next.js frontend stack.

Viralix

Web research platform for YouTube creators focused on finding competitors, tracking channels, and analyzing video performance using the YouTube Data API. The project includes user accounts and a Supabase-backed database, plus subscription management with Stripe. It also provides an AI credits system and a Kanban-style content planner with statistics.

Junior Backend Developer Confidence: Medium API Engineer

Local-first desktop app engineer (approx. middle level) focused on file-backed Tauri applications and safe filesystem-backed state. The strongest proven skill is careful file I/O and metadata handling demonstrated by the Rust backend (Notes/src-tauri/src/lib.rs) with atomic writes, metadata frontmatter encode/decode and unit tests. There is limited evidence of distributed systems, large-scale performance tuning, service orchestration or production observability in the public code.

API Design

5/10

How well APIs are designed

Clear local API surface between the renderer and native backend using Tauri commands, consistent error-return shape (Result<T, String>) and input validation, but no formal versioning, idempotency keys, or advanced pagination/contract layering.

Evidence

Koki4a08/Notes/src-tauri/src/lib.rs: #[tauri::command] get_settings, update_settings, list_notes, save_note, delete_note, restore_note, share_note_with_agent Koki4a08/Notes/src/lib.ts: getSettings/updateSettings/listNotes/saveNote providing a browser fallback that mirrors the Tauri invoke contract

Data Layer & Database

4/10

Working with databases

File-backed data layer with explicit metadata schema and careful I/O patterns (atomic temp-write + rename) and validation; no database migrations or advanced transaction/isolation logic because storage is the filesystem.

Evidence

Koki4a08/Notes/src-tauri/src/lib.rs: Note struct, encode_note/decode_note implementing JSON frontmatter metadata Koki4a08/Notes/src-tauri/src/lib.rs: save_note writes to a .md.tmp then fs::rename for atomic replace; note_path validation rejects directory traversal and invalid ids

Scalability & Performance

2/10

Handling load and speed

Appropriate for a local desktop app but limited scalability work; uses spawn_blocking to avoid blocking the async runtime but no caching strategy, queueing, or measured performance optimizations for larger datasets.

Evidence

Koki4a08/Notes/src-tauri/src/lib.rs: tauri::async_runtime::spawn_blocking used in get_settings/list_notes/save_note to offload blocking filesystem work

System Architecture

4/10

Overall system structure

Reasonable separation between backend (Rust/Tauri) and frontend (TypeScript) with a browser-preview mock layer, but architecture is single-app local scope without multi-service decomposition or cross-service contracts.

Evidence

Koki4a08/Notes/src-tauri/src/lib.rs: Rust Tauri backend exposing commands Koki4a08/Notes/src/lib.ts: browser-side fallback that mirrors the backend API surface

Security & Auth

5/10

Protecting data and access

Good basic boundary hygiene and sanitization for a local app: strict id/path validation, controlled metadata parsing, and HTML sanitization in the frontend; no auth or secrets flows are implemented here.

Evidence

Koki4a08/Notes/src-tauri/src/lib.rs: note_path rejects invalid ids and directory traversal; decode_note verifies frontmatter format Koki4a08/Notes/src/markdown.ts: DOMPurify.sanitize used after marked.parse to sanitize rendered HTML

Reliability & Observability

4/10

Stability and monitoring

Evidence of unit tests and UI smoke automation plus careful atomic writes and error propagation; limited observability (no structured logging/metrics) and no retry/backoff patterns for transient failures.

Evidence

Koki4a08/Notes/src-tauri/src/lib.rs: #[cfg(test)] unit tests (markdown_round_trip_preserves_note, note_path_rejects_directory_traversal) Koki4a08/Notes/scripts/ui_smoke.py: Playwright-based UI smoke test that exercises browser flows and produces screenshots

Expertise

Rust· Junior

Node.js· Junior

Technologies

Rust· Junior

Rest API

Tokio

Serde

Recommendations

Develop local-first desktop applications that require robust file I/O, metadata formats and safe on-disk storage (Tauri + Rust backends).
Build file-backed productivity tools (notes, journals, small editors) where atomic writes, path-validation and sanitization matter.
Implement TypeScript frontends that integrate with native backends and provide browser preview fallbacks and automated UI smoke tests.
Own features that require careful input sanitization and safe sharing/export manifests (agent/share manifest patterns)

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

Koki4a08 design-gravity Notes

Junior Frontend Developer Confidence: Medium App Engineer

UI Component Architecture

2/10

How interface parts are built

Basic, pragmatic component and module separation is present (backend abstraction vs UI), but there is no evidence of a deliberate component library, composition patterns, or custom lifecycle hooks for complex widgets.

Evidence

Notes/src/lib.ts: tauri vs browser fallback encapsulated in small backend-like helper functions (getSettings, listNotes, saveNote)

Notes/src/styles.css: consistent class naming and UI surface separation that supports componentized UI even if React components themselves are not in the human-authored files

Responsive & Cross-browser

5/10

Works on all screens and browsers

Responsive CSS and accessibility-conscious fallbacks are implemented via media queries and prefers-reduced-motion; cross-browser polish (scrollbars, focus-visible) is present but there is no advanced feature-detection or container-query driven layout in the human-authored files.

Evidence

Notes/src/styles.css: multiple @media rules for breakpoints (max-width: 900px, 740px) and a prefers-reduced-motion block

Notes/index.html: lang attribute and viewport meta present

Performance Optimization

1/10

Speed of the interface

No measured performance work, bundle analysis, long-list virtualization, or advanced code-splitting is visible in the human-authored code; only minimal runtime branching (Tauri vs browser) reduces unnecessary calls.

Evidence

Notes/src/lib.ts: inTauri runtime guard (typeof window check) to avoid invoking Tauri in browser preview

Notes/src/styles.css: uses prefers-reduced-motion to disable animations for reduced-motion users (minor perceived-performance/a11y improvement)

Accessibility & Semantics

5/10

Usable for everyone

Concrete accessibility-oriented CSS exists (focus-visible outlines, reduced-motion), and index.html includes basic semantics; however there is limited evidence of ARIA on custom widgets, keyboard focus management in JS, or CI a11y tooling.

Evidence

Notes/src/styles.css: :focus-visible style rules for form controls and custom-select handling; handling of prefers-reduced-motion

Notes/index.html: lang attribute and meta tags set appropriately

State Management & Data Flow

3/10

Managing data in the app

Clear, pragmatic state/data flow for a desktop/browser fallback is implemented (localStorage and Tauri invocation abstraction, save/restore/delete flows), but there is no server-state management, request cancellation, optimistic rollbacks, or state machines.

Evidence

Notes/src/lib.ts: listNotes/saveNote/deleteNote/restoreNote implement localStorage fallback and Tauri invoke calls

Notes/src/lib.ts: shareNoteWithAgent builds an agent manifest path and throws if note not found (simple error handling)

UX & Visual Polish

6/10

Look and feel quality

High visual and UX polish in the CSS (empty states, skeleton/animations, well-scoped editor styles and transitions) indicates a good eye for UX and perceived performance; these are mostly static style artifacts with little evidence of UX logic complexity in JS.

Evidence

Notes/src/styles.css: detailed empty-state, animations (note-settle, dialog-settle), rich-editor placeholder styling and editor layout

Notes/src/lib.ts: newNote, notePreview and inferTags provide UX-friendly utilities used by the UI

Expertise

React· Junior

HTML & CSS· Junior

Industries

Software· Junior

Technologies

Frontend

JavaScript

Node JS

Tailwind CSS

Next.js

Electron

Git

React.js

Vite

PostCSS

GitHub

Recommendations

Use them to implement local-first desktop apps and Electron/Tauri frontends with Markdown-rich editors and file-backed sync.
Assign UX polish, CSS theming and design-token work where careful visuals and reduced-motion/accessibility matter.
Have them own small-to-medium front-end features (notes, editors, settings) that require TypeScript + runtime platform fallbacks.
Encourage them to add explicit async discipline (cancellation/optimistic updates) and unit/integration tests to level up toward senior frontend roles.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

Koki4a08 design-gravity Notes

Junior QA Engineer Confidence: Medium Automation Engineer

A UI automation-focused engineer (mid junior to lower-middle level) who builds end-to-end smoke tests and TypeScript utilities. The strongest proven skill is writing Playwright-based UI smoke scripts that exercise many user flows and capture artifacts, as shown in Notes/scripts/ui_smoke.py. There is little public evidence of CI integration, contract or API testing, performance testing or a dedicated test infrastructure with fixtures and isolated mocks.

Test Automation Frameworks

3/10

Building automated tests

Evidence of end-to-end UI automation using Playwright in a standalone smoke script with selector discipline and screenshots, but no fixtures, no parallelization and several fixed sleeps that reduce robustness.

Evidence

Notes/scripts/ui_smoke.py: Playwright smoke test using get_by_role/get_by_label selectors, console error capture, screenshots

Notes/scripts/capture_reference.py: Playwright script to capture a reference screenshot

Test Coverage & Strategy

2/10

What and how to test

A single, comprehensive smoke script covers many happy paths and UI interactions but lacks negative-path tests, boundary assertions, risk-based tagging, property-based tests or structured test organization.

Evidence

Notes/scripts/ui_smoke.py: happy-path flows, assertions for visibility and counts, but no explicit negative-case assertions or test tagging

API & Integration Testing

Testing how parts work together

Not evidenced in public code

Performance & Load Testing

Testing speed under load

Not evidenced in public code

Bug Reporting & Analysis

Finding and describing bugs

Not evidenced in public code

CI Test Integration

Running tests automatically

Not evidenced in public code

Expertise

SDET & Test Engineering· Junior

Industries

Design & Creative· Junior

Technologies

TypeScript· Junior

Playwright

Vitest

Recommendations

Expand the Playwright scripts into a structured test suite with fixtures, per-test setup/teardown and a test runner integration for CI.
Replace fixed wait_for_timeout sleeps with conditional waits and targeted retries to reduce flakiness and improve test reliability.
Add negative-path and boundary tests (explicit error states and exact expected failures) and small contract checks for any native/Tauri IPC interactions.
Introduce simple test doubles or a mock Tauri backend and clear data isolation so UI smoke tests run deterministically.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

design-gravity Notes