Slice's consumer app is an online ordering marketplace for local pizzerias, with order tracking, order history, payments, and rewards.

I worked on the order-tracking experience and integration with the Owners app, alongside improvements to stability and maintainability, in an app with millions of monthly sessions.

My reliability work emphasizes finding defects before release. When issues surface, I assess whether they affect the core ordering flow and what percentage of users is affected. Most features launch behind feature flags, and every flag can be disabled remotely without waiting for an App Store update.

The established codebase combines UIKit and SwiftUI, primarily using MVVM with coordinators. Its technologies include RxSwift, Combine, Swift Concurrency, and SnapKit, with Quick and Nimble used for testing.

An iOS app that connects pizzeria owners with Slice and helps them manage their shops.

I took ownership of the codebase and worked with the team to rebuild the app using modern components. We simplified and improved the networking stack and strengthened stability and monitoring, reducing networking issues experienced by users.

The simpler stack helped the team deliver changes faster. Components standardized through this work were later adopted across Slice. I also improved documentation and testability so more developers could contribute, and worked with product owners and project managers to define and plan changes.

My work on the app included a UIKit and RxSwift codebase with an MVVM architecture, a programmatic interface, and constraints managed through SnapKit.

Slice Register is an iPad point-of-sale app for pizzerias.

I worked on the enabling team responsible for stability, deployment, monitoring, and APIs used by other iOS developers. The POS app needed a controlled way to evolve its data as installed apps moved between versions. That extended beyond the database to UserDefaults, in-memory state, and data read from remote services.

I designed the storage versioning and migration processes, including how database versions were defined and how migrations were executed, documented, and tagged. Within the large Swift and Objective-C codebase, I rewrote the Core Data stack and improved the broader storage infrastructure, increasing observability and testability.

I also improved testability by introducing dependency injection with Resolver and improving existing tests. The app used MVVM with routing for navigation, alongside Combine and Swift for newer features.

Slice Driver is the delivery app used by drivers on the Slice marketplace, part of the Slice Register ecosystem.

It helps drivers review order contents, launch navigation with one tap, and keep delivery progress updated in real time.

The app is built natively in Swift with UIKit and integrates real-time delivery state handling, order verification flows, and location-based navigation support for drivers on the road.

The tech stack is UIKit with MVVM architecture.

I did maintenance and bug fixes on the app, while improving reliability and maintainability of key delivery flows, and ensuring the ordering lifecycle is easy to complete under difficult networking conditions.

Mobile app for the local ZOO.

I have implemented offline and custom map using map tiles and MapKit. Offline navigation is also supported and uses custom GPX file to map the ZOO paths. Using CoreLocation it is able to determine navigation path, from user location to selected point (animal) in the map and draw the path on the map.

The UI is build using UIKit and storyboards. Every model and image that is used in the app is also saved on device to support offline usage. For images I have used Kingfisher and the models are simply converted to data and saved into UserDefaults.

Some of the descriptions of the animals also have audio playback, this is implemented with AVAudioPlayer.The app also offers ticket purchase which is done through native screens up until the payment, which redirects to Webview where the payment is completed.(this was due to the limitation of the payment provider).

Navigation is done through a left sliding menu, using the open source library SideMenu. The menu has 3 options each of which underneath is a UINavigationController, then ViewControllers are pushed or presented from the root UINavigationControllers.

This app is used for previewing and signing of PDF documents.
This app was implemented using PDFKit at its core. It uses Apple's framework to preview and edit PDF documents. The UI is build using UIKit and storyboards. On double tapping the PDF document a zoomed in screen shows up that accepts drawing of signatures, this is done by drawing with the help of UIBezierPath objects. After the drawing is complete, and scaling is taken into consideration, there is the option to resize the signature view, on completion the signature is transformed into a PDFKitAnnotation object and stamped onto the PDF file, saved locally.

Storing and retrieving files is done through Apple's file system so everything is saved on device. Standard FileManager is used to achieve this.

The library that was used to distribute this code across multiple project was XCFramework bundle. Later the said library was imported as a static library to other Xcode projects.

Retail native app for consumer electronics retail store.

This was an MVC app using storyboards and build with Swift. I set up the networking architecture which used Alamofire networking. The images were loaded and cached using Kingfisher. The app supported and was localized in 2 languages.

The navigation of the app was build using a UITabBarController with 5 UINavigationController which represented each different tab. Based on the user state(logged in/out) the 4th tab would be loaded dynamically. The dashboard was build using separate UIViewController for each section which were nested into container views.

Users could insert their loyalty card in their profile by scanning their physical card, and also generation of loyalty's card barcode was possible if it was previously added. This would mean users wouldn't have to carry their physical card if they had the mobile app.

After the items were added to the card the users could complete the purchase and insert all their information(or it was pre-filled if logged in) in native UI forms. The final step of inserting payment details was done through a web view because of payment provider limitations.

StopKorona! was North Macedonia's COVID-19 exposure notification app.

At the height of the pandemic rush, it reached roughly 100,000 users and became the top app on the local App Store.

The app used the Apple/Google Exposure Notification system and Bluetooth-based proximity detection to privately inform users when they may have been in close contact with someone who later reported a positive COVID-19 test.

Before Apple and Google released the Exposure Notification APIs, earlier versions of the app used custom Bluetooth Low Energy (BLE) logic to detect nearby devices and record encounters. If a user reported a positive test, they could choose to upload their anonymized contact traces, and other users would be notified if a match was found. Devices emitted randomized identifiers to preserve privacy.

I worked on the app's Bluetooth logic and UI.