Technodom

Project Overview

Technodom is the leading electronics retailer in Kazakhstan. This was my first experience working in a large-scale Agile team (10+ developers). The project was built on Magento 2 with a ScandiPWA (React) frontend. I progressed from implementing basic frontend tasks to owning full-stack features and navigating a massive codebase.

UI Components & CMS Integration

My initial work focused on creating reusable components manageable via the backend. I developed WYSIWYG-compatible React components, which allowed the marketing team to edit information blocks and banners directly without needing developer intervention.

I also built the Product Cards and Product Detail Pages (PDP). The design required complex labeling logic (for sales or new items) and strict responsiveness. I used SASS with the BEM (Block Element Modifier) methodology to keep the styling organized and maintainable.

Advanced React Logic: Product Comparison

One of the more complex frontend features I built was the Product Comparison tool. This allowed users to select multiple items and view them side-by-side. Technical challenges included managing a persistent state so selections remained after a page reload.

Full-Stack Implementation: Favorites System

My most significant technical contribution was the Favorites/Wishlist feature. Since this specific logic was not available in our base setup, I had to build it from scratch across the entire stack:

1. Database (MySQL): I created custom tables to store user wishlist items.
2. Backend (PHP/Magento): I wrote the logic to expose this data.
3. API (GraphQL): I implemented custom queries and mutations (add, remove, fetch).
4. Frontend (React): I connected the UI to these new endpoints.

Cart Logic & Recommendations

I also worked on the Shopping Cart, implementing real-time price calculations, item removal, and quantity updates. To help increase sales, I added a “Product Recommendations” carousel inside the cart, which fetched related items based on the user’s current selection.

Integrations & Teamwork

Beyond core features, I handled third-party integrations, such as the Newsletter Subscription. This was challenging because it used an embedded iframe that did not match our site’s design. I used inline CSS injection and DOM manipulation to force the third-party form to look consistent with our brand.

As I gained experience, I also began helping the team with Code Reviews and QA, ensuring that features merged into the main branch met our quality standards.

Crochet App

Project Scope & Commercial Impact

During my time at Chili Labs, I took full ownership of the development for Crochet App. My work covered the entire lifecycle - from coding complex features and managing App Store releases to handling “under the hood” tasks like Flutter migrations and crash reporting. The highlight of this project was the commercial impact of my engineering. By completely revamping the user’s first impression and optimizing the payment flow, I successfully doubled the app’s monthly revenue.

Monetization & User Retention

First, I engineered a new Onboarding feature. Originally, users were dropped into the app with little guidance. I built an interactive multi-step setup flow where users could select their preferences and immediately understand the app’s value (like adding yarns or hooks). This drastically improved user retention, ensuring more people stayed in the app long enough to consider subscribing.

Second, I overhauled the subscription system. I built a dynamic mechanism to serve different “Call to Action” screens, ranging from simple designs to complex video-based layouts. Using Firebase Remote Config and Analytics, I ran A/B tests to see which version performed best. The combination of better onboarding and data-driven A/B testing was directly responsible for the 100% increase in income.

Cloud Architecture & AWS Integration

One of the core features I built was a digital catalog for users’ physical tools. This required a hybrid cloud approach. I integrated the Camera API to capture images and utilized AWS S3 for efficient storage, while syncing the metadata to Firebase. This allowed me to learn the AWS SDK to handle secure authentication and file uploads within the Flutter environment.

Optimization: The “Offline-First” Syncronisation

The most complex technical challenge was the Yarn Database. We needed to serve a massive dataset of yarn types to users, but downloading this from Firebase on every app launch would have been incredibly slow and expensive due to read-operation costs.

I solved this by engineering a custom incremental sync system. The app stores a local JSON copy of the database and, upon launch, checks the server only for changes (diffs). If there are updates, it downloads just the new data; otherwise, it loads instantly from local storage. This solution ensured the app worked 100% offline.

Voice Commands Feature

I also worked on the voice commands feature, which allowed users to control the app hands-free while crocheting. This involved integrating a speech recognition library to add or remove rows on the pattern list. In the end the feature failed but was the main inspiration for me to work on the Bachelor’s thesis.

TinyEar

The Research Problem

For my Bachelor’s degree, I investigated the technical limitations of mobile speech recognition. Cloud-based APIs create inherent privacy risks and latency issues and also includes high expenses, while existing offline solutions often suffer from poor accuracy. My objective was to bridge this gap by bringing the accuracy of OpenAI’s Whisper model to mobile devices in a fully offline environment.

Systems Engineering (JNI & C++)

I developed TinyEar as a reusable Android library. The core challenge was performance, as running a Transformer model on a mobile CPU is resource-intensive. To address this, I bypassed standard Java execution layers. I wrote a C++ integration layer using the Java Native Interface (JNI) to run TensorFlow Lite models directly on the native hardware.

Capabilities & Implementation

1. File Transcription Accuracy The library processes raw audio files to generate text with high precision.

2. Real-Time Processing Using the JNI optimization, the library performs live transcription directly from the microphone stream without blocking the main UI thread.

3. Voice Command Pipeline I implemented an interpreter that maps natural speech to executable functions.

• Input: “Show time” → Action: Displays Clock.
• Input: “Say Hello” → Action: Outputs greeting.

Performance & Optimization

A major focus of the thesis was resource efficiency. A naive implementation would drain the battery by running the inference engine continuously.

To solve this, I implemented Voice Activity Detection (VAD). The system analyzes the raw audio signal to detect silence and only triggers the resource-intensive ML model when actual speech patterns are present. Additionally, I implemented a “Wake-Word” logic gate. The system monitors the stream for a specific keyphrase (e.g., “Okay Phone”) and executes commands only when this phrase is recognized.

Results

In the thesis benchmarks, TinyEar demonstrated a significant reduction in Word Error Rate (WER) compared to legacy libraries like PocketSphinx. The library is currently available on GitHub as an open-source solution for privacy-focused Android applications.

Sophie Conran

Project Architecture & Stack

I worked as a Frontend Developer for Sophie Conran, a high-end British kitchenware brand. The platform was built on Magento 2 with a ScandiPWA frontend. My role involved translating the brand’s rigorous design requirements into functional React components, communicating with the Magento backend via GraphQL.

Headless CMS Integration (The Blog)

I was responsible for engineering the site’s Blog. To allow the non-technical marketing team to manage content easily, I implemented a Headless CMS workflow. The client used the standard WYSIWYG editor in Magento to create blog posts. I then built a custom React component that fetched this content via GraphQL and rendered it on the frontend. This decoupling allowed the marketing team to update blog content without needing any developer intervention, while still maintaining the site’s design integrity.

Complex UI Engineering: The “Smart” Sidebar

The most technically challenging feature was the navigation sidebar. The requirements went beyond standard CSS capabilities: the sidebar needed to be “Sticky” yet “Scrollable.”

Since the sidebar content was often taller than the user’s screen, a simple position: sticky would cut off the bottom options. I wrote a custom JavaScript calculation engine that monitors scroll direction and viewport boundaries.

• Logic: If the user scrolls down, the sidebar stays pinned until the bottom is reached. If they scroll up, it re-aligns to the top.
• Result: This logic ensures the user can always access the full menu regardless of screen size, creating a polished, app-like feel essential for a luxury user experience.

RunQuest (Qualification Work)

Project Context & Scope

This project served as my final qualification work for Rīgas Valsts Tehnikums, where I successfully defended my thesis with a grade of 8/10. The objective was to combat user attrition in fitness apps by engineering a “Gamified” running experience. The project was not just about writing code, it was a comprehensive exercise in the full software engineering lifecycle, requiring a 151-page technical paper covering requirements gathering, system modeling, and implementation.

System Architecture

I designed a decoupled full-stack architecture to ensure the mobile client remained lightweight while the server handled the complex logic.

• Mobile Client (Flutter): I utilized Flutter for its cross-platform capabilities. The app handles geolocation (Google Maps) and sensor fusion (GPS + Accelerometer) to track user movement in real-time.
• API Layer (GraphQL): I implemented a GraphQL API using graphql-yoga. This was a strategic decision to allow the mobile app to query exact data requirements (e.g. specific inventory stats) in a single HTTP request, minimizing data usage for mobile users.
• Database (MySQL): I designed a Normalized Relational Database to ensure data integrity. The schema required complex mapping for Many-to-Many relationships, particularly regarding User Inventories and Social Graphs (Friends/Challenges).

Key Features

1. Secure Authentication & Session Management Security was a priority requirement for the qualification. I implemented stateless authentication using JWT (JSON Web Tokens) and secured user credentials using bcrypt hashing. I also implemented session handling logic to manage token expiration and secure storage on the device.

2. The “Anti-Cheat” & Game Logic Since the app involves a virtual economy (Coins/XP), validating runs was critical. I engineered server-side logic to analyze incoming GPS timestamps and distance. The system flags runs that exceed human speed limits (for example using a car) to prevent economy inflation.

3. Inventory & Transactional Integrity I built a robust inventory system where users can equip items for their avatar. The backend enforces strict logic constraints. For example, it ensures a user cannot equip two items of the same “slot type” (like wearing two hats) simultaneously.

Professional Growth

This project was a pivot point in my career. It was my deep dive into Typed Languages (transitioning to Dart) and Backend Systems Design. The experience of documenting the entire lifecycle, from the first UML diagram to the final APK build, gave me a strong foundation in how professional software is specified and delivered.

Bondora Go & Grow App

Project Overview

The Bondora Go & Grow App was a significant milestone in my career at Chili Labs, marking my first substantial contribution to a production-level mobile product. Bondora required a complete overhaul of their investment application, necessitating a transition from an outdated interface to a modern, responsive UI built with Flutter.

I worked in close collaboration with a senior mentor to deliver this vision. While my mentor architected the complex main dashboard, I assumed full responsibility for implementing the core user journeys. This included the onboarding flows, authentication systems, account selection, and detailed transaction views.

Technical Challenge: Legacy API Integration

A primary engineering challenge was the integration of a Legacy REST API. The existing backend infrastructure was built around an older design paradigm, which often resulted in inconsistent or partial data responses that did not align with the new UI requirements.

To bridge this gap, I had to write adaptation logic that mapped, combined, and restructured these API responses into a clean, usable state for the frontend. This required not just coding, but careful reasoning about data relationships to ensure the modern interface functioned smoothly without altering the backend.

Key Features & Custom Components

Beyond standard UI implementation, I engineered several custom components to meet specific financial compliance and usability standards.

• Custom Currency Input: I built a dynamic input field that formats values in real-time as the user types. It automatically adapts to specific spacing and delimiter preferences and enforces configurable maximum transaction limits.

• Interactive Account Dashboard: I implemented the logic for displaying dynamic financial data, including interactive graphs and detailed transaction statements.
• Redesigned User Flows: I engineered the complete lifecycle for the Login, Account Overview, and Detail screens, ensuring a seamless user experience from app launch to investment management.

Quality Assurance & Architecture

To ensure long-term maintainability and stability, we adopted a strict BLoC architecture combined with MVC conventions. My responsibilities included:

• Unit Testing: I wrote production-ready unit tests for all new features, ensuring full coverage for the logic I implemented. This rigorous testing approach was crucial for a financial application where calculation errors are unacceptable.
• Cross-Platform Delivery: I ensured the application rendered and behaved consistently across both iOS and Android devices, handling platform-specific nuances in the UI.

Professional Growth

This project significantly accelerated my competence with the Flutter framework. It transitioned me from a learner to an independent developer capable of owning large feature sets. I learned to navigate the complexities of enterprise software development, from collaborating with QA teams to managing the constraints of legacy systems, ultimately contributing to a successful production release.

Cervera

Project Context

Cervera, a leading Swedish kitchenware and home accessories retailer, initiated a full platform modernization effort. Their existing site relied heavily on server-side rendered .NET pages, lacked a proper API layer, and needed a transition toward a React-based single-page application (SPA) without breaking ongoing business operations.

My Contribution

Working as a front-end focused developer with backend responsibilities, I helped drive the migration from a multi-page .NET Core setup to a modern .NET + React architecture. My primary role involved bridging the gap between the legacy system and the new design:

• Migration: I migrated UI components into React and transformed user flows to work within a SPA model.
• Backend Adaptation: I refactored existing .NET controller logic to deliver structured data to the client instead of HTML.
• Bridging Solutions: Where APIs did not yet exist, I created temporary data-passing methods (e.g., via script tags) to maintain feature continuity.

Outcome

The redesigned React SPA is now live in production, offering smoother navigation, fewer reloads, and a more maintainable codebase. Through this project, I developed strong hands-on experience with .NET internals, React SPA design patterns, and the practical challenges of modernizing a legacy system while keeping the site operational.

Atrodi Skolu

Project Overview

For my first hackathon, my team and I tackled a UX problem: government data on schools and kindergartens existed but was buried in inaccessible spreadsheets. We wanted to visualize that data on an interactive map. The project was a success; we were selected as finalists and invited to present our solution at the LMT Headquarters.

Engineering The Solution

I was responsible for the Frontend Engineering, writing the JavaScript logic to fetch data from our SQL database and render it onto Leaflet.js map markers.

The Data Challenge: A critical issue was that the raw government dataset provided addresses but lacked GPS coordinates, preventing us from placing markers on the map. Instead of manually finding coordinates for thousands of entries, I devised an automated workflow. I piped the addresses through the Google Maps API to batch-convert them into coordinates. We then imported this “clean” dataset into our SQL database, allowing the app to function with real-world accuracy.

Additional Data Challenges:
Another challenge was that there was not data for universities and trade schools. This part could not be automated, so I manually had to find and add these institutions to the database. Including the profession and education you could get there.

Results & Professional Growth

This project laid the foundation for my geospatial development skills. Mastering Leaflet.js and data normalization here directly enabled me to build more complex applications later. More importantly, it taught me how to integrate my frontend logic with a teammate’s backend architecture and how to present technical products in a high-pressure environment.

CitySense (LATA Hackathon 2019)

The Concept: “Comfort-First” Navigation

Most navigation apps optimize purely for speed. However, as a daily commuter in Riga, I knew that the “fastest” route often meant being squeezed into a packed bus. To solve this, I designed CitySense, a routing engine that optimized for Passenger Comfort. The app allowed users to trade a few minutes of travel time for a significantly more pleasant, less crowded ride.

An image from my project of how the app crudely would visualize bus crowding levels. Currently it shows every route in the city with random thickness. As a prototype on how it could look in the future, it was sufficient to demonstrate the concept.

Engineering & Data Logic

I served as the Lead Full-Stack Developer for this project, building the majority of the application within the 48-hour timeframe.

The core engineering challenge was determining how to know if a bus was full without real-time sensors. I devised a predictive model using Rīgas Satiksme Open Data:

1. Data Ingestion: We analyzed timestamps of registered tickets (e-talons) at specific stops.
2. Predictive Modeling: Since commuter traffic follows routines, we mapped historical density to specific times.
3. Visualization: The app combined this data with OpenStreetMap to show a “Crowd Heatmap” for upcoming vehicles.

Retrospective

We successfully presented a functional demo. While I successfully integrated a complex stack (React, GraphQL, Laravel), doing so under extreme time constraints was a valuable lesson in software architecture. I learned that for rapid prototyping, choosing a familiar, lightweight stack is often superior to over-engineering with complex tools like GraphQL.

Ace Your Trace

Project Context

Ace Your Trace was a weekend hackathon project built by a small team, designed to help users generate simple, personalized walking routes during the COVID-19 pandemic. The objective was to provide a tool for exploring surroundings within a specific distance while public spaces were closed, similar to concepts like Routeshuffle.

Despite the 48-hour time constraint, we delivered a functional prototype that allowed users to select a starting point, input a target distance or duration, and view a generated loop route in seconds. This rapid execution earned our team 3rd place at the event.

Technical Implementation & Features

I focused on the core map and routing logic, integrating OpenStreetMap and Leaflet to handle the visualization. The application leverages the Geolocation API to identify the user’s current location and a Directions API to calculate paths.

The system supports granular customization, allowing users to define specific parameters such as distance and duration. Once the parameters are set, the application generates the route and renders it on the map using polylines for clear visualization. The UI was designed for real-time feedback; as users adjust their inputs via the simple control panel, the map and route data update dynamically without requiring a page reload.

Architectural Refactoring

While the hackathon version was functional, the code was tightly coupled and difficult to extend. After the event, I revisited the project to restructure it into a professional, modular architecture using ES6 modules. I enforced a strict Separation of Concerns by dividing the logic into dedicated classes:

• Settings: Manages user preferences and input validation.
• MapController: Handles map interactions and rendering logic.
• RoutingService: Manages API calls and route calculation.
• UIController: Handles user interface events and DOM updates.

To ensure a smooth user experience, I utilized modern JavaScript practices, including Async/Await and Promises, to handle the asynchronous nature of routing requests and map updates.

Business Viability & Market Research

Following the hackathon, we explored expanding the prototype into a viable business platform. We designed a framework that layered gamification over the routing logic, including Challenges tied to physical locations, a Rewards Mechanism for completing tasks, and Social Sharing features to compete with friends.

We also investigated a location-based advertising layer, where sponsors could place branded challenges or venues on the map. In retrospect, this model shares significant similarities with Pokémon GO’s Sponsored Locations and the event-driven marketing strategies used by local shopping centers (e.g., Akropole Alfa) to attract foot traffic. Although we ultimately decided not to pursue the project further, the experience provided valuable insights into rapid prototyping and the commercial potential of location-based services.

Bank App

Project Context

This project originated as a coursework assignment at Rīgas Valsts Tehnikums. The objective was to design and build a functional banking application using Java and Object-Oriented principles. I completed the initial development independently over a two-week period, implementing the full stack from the JavaFX user interface to the MySQL database integration.

Later in my development journey, I revisited this codebase to refactor it. My goal was to apply the advanced design patterns and architectural discipline I had learned since the initial submission, transforming a student project into a cleaner, more structured application.

Architecture and Design

I structured the application using the Model-View-Controller (MVC) pattern to ensure a clean separation of concerns:

• Model: Defines the data entities (Users, Accounts, Transactions) and business rules.
• View: Manages the UI presentation using JavaFX and FXML layouts.
• Controller: Handles user input, orchestrates validation logic, and updates the Model.

To manage the UI state effectively, I implemented the Observer Pattern. This allowed the interface to react dynamically to user actions. For example, enabling or disabling transaction buttons based on the currently selected account in the table view.

Key Features

1. Admin Capabilities & Authentication

The system mimics real-world banking procedures where account creation is a controlled process. I implemented an Admin Panel that allows staff to create new users and generate accounts. Security was a priority, so I integrated bcrypt hashing to ensure user passwords are never stored in plain text.

2. Account Operations & Business Logic

The core of the application handles financial transactions—deposits, withdrawals, and transfers. I engineered strict validation logic to ensure data integrity, performing existence checks and verifying sufficient balances before any transaction is processed.

I also implemented specific business rules (as that was in the task specification) to differentiate account types:

• Credit Accounts: Users receive a 5% discount on transaction fees.
• Savings Accounts: Users receive a 5% bonus on deposits (excluding internal transfers between their own accounts).

3. Data Logging & Reporting

To support auditing, I built a logging system that records critical actions such as account creation and fund transfers directly into the MySQL database. This data allows administrators to generate reports and track the history of operations within the system.

Refactoring and Lessons Learned

Refactoring the code provided valuable insight into software architecture. My initial implementation updated account balances directly in the database. Upon revisiting the project, I realized that a more robust approach for financial systems is to derive balances from a transaction ledger.

This project was an essential step in understanding how to enforce business rules programmatically and the importance of using established patterns like MVC to keep codebases adaptable as they grow.

Giphy Search Engine

Project Overview & Architecture

The goal of this project was to build a cross-platform mobile application that interfaces with the Giphy REST API. To ensure maintainability and testability, I architected the application using the MVVM (Model-View-ViewModel) pattern. For state management, I utilized Provider to separate business logic from the UI effectively. This separation allows the interface to remain reactive and lightweight, updating only when the underlying data state changes.

Performance Engineering

Handling media-heavy applications requires strict attention to performance and memory management. I implemented two key optimizations to solve this:

• Network Optimization (Debouncing): To prevent API rate-limiting and save data, I engineered a custom “Debouncer.” This delays the API call until the user stops typing for a set duration, significantly reducing unnecessary network requests during input.
• Infinite Pagination: Instead of loading thousands of images at once, I implemented lazy loading. The app monitors the user’s scroll position and automatically fetches the next batch of GIFs as they approach the bottom of the list, ensuring smooth 60fps scrolling and low memory consumption.

User Experience & Resilience

A key focus was ensuring the app handles edge cases gracefully. I implemented robust error handling to manage connectivity issues or invalid API responses. The UI dynamically updates to show helpful feedback, rather than leaving the user with a blank screen or an app crash.