Open to remote & product engineering roles
Astana, Kazakhstan · Mobile + AI

I build apps.
And what’s next.

I'm Dias, a software engineer who ships native iOS and Flutter products—and builds AI-powered ideas into real, usable applications. From mobile architecture to the API, database, and deployment.

dias / build.ts
const engineer = {
  name: 'Dias Saiynov',
  focus: ['iOS', 'Flutter'],
  tools: ['SwiftUI', 'AI'],
  mindset: 'ship & learn'
};
 
// turn ideas into working products
await build(idea);
await test(product);
await ship(product);
Swift · Dart · TypeScript● Building
idea → prototype → product ✓
3+ yearsMobile engineering
iOS + AndroidProduction platforms
AI + APIsIndependent product builds
CS graduateNazarbayev University
01 / Selected work

Things I've built.

Commercial products, independent experiments, and AI tools with real working interfaces—not just concepts.

Native iOS · Personal project

Clario — intelligent productivity

A native SwiftUI productivity app exploring API-powered intelligence, persistent data management, and clean, focused interactions.

SwiftSwiftUIAPI integrationPersistence
HackAlem AI · 2026

Alem Match — vendor recommendations

A five-hour hackathon build: deterministic vendor matching from 66 profiles, fallback rules, automated scenarios, and AI-generated explanations. Jury evaluation: 86/100.

Next.jsTypeScriptOpenAI APIRecommendation logic
Flutter · Personal project

WalletWise — personal finance

Cross-platform finance app using feature-based Clean Architecture, BLoC, navigation, local persistence, and monitoring.

FlutterBLoCIsarSupabaseSentry
Python · AI automation

AI Telegram assistant

An asynchronous Telegram bot with OpenAI integration, PostgreSQL persistence, and Railway deployment. A compact example of connecting LLMs to real workflows.

PythonaiogramPostgreSQLOpenAI

02 / Engineering case study

One product.
Two platforms.

At KoraTalk, I worked across the lifecycle of a real mobile product—from native iOS to a shared Flutter implementation.

View App Store ↗
Read the migration story ↗
01 · Native foundation

Built with SwiftUI

Developed iOS screens, reusable UI, networking, and product flows including bookings and subscriptions.

02 · Cross-platform migration

Moved to Flutter

Implemented Flutter feature modules within the architecture led by a senior developer, and later participated in reviews and releases.

03 · Product delivery

Maintained the experience

Worked with backend, design, and QA to develop features, troubleshoot issues, and support iOS and Android releases.


03 / Technical writing

Notes from building.

Practical lessons from native iOS, Flutter, architecture, and building products in real teams.

ARTICLE 001 · ENGINEERING STORY

From SwiftUI to Flutter:
Why We Switched and What I Learned

How we rebuilt an existing SwiftUI app for two platforms, what changed in our architecture, and why a shared codebase doesn't eliminate native challenges.

November 202611 min readBy Dias Saiynov
SwiftUIFlutterBLoCArchitectureViewModel
Read full articleCollapse article
Engineering retrospective · KoraTalk

From SwiftUI to Flutter: Why We Switched and What I Learned

How rebuilding a production iOS application for two platforms changed the way I think about mobile development, architecture, and engineering decisions.

1. How I Got Into iOS Development

When I started studying Computer Science, I wasn't sure which direction I wanted to take. I explored different areas of programming, but nothing really caught my attention until I discovered iOS development.

It started when my father gave me a MacBook Pro. I finally had the opportunity to explore Apple's development ecosystem, so I started learning Swift and SwiftUI through Udemy courses, books, tutorials, and personal projects.

I enjoyed building interfaces, seeing my code come to life on an actual device, and understanding how iOS applications worked behind the scenes.

My first experience working in a development team was at Qpia, a Kazakh language-learning application. Unlike my personal SwiftUI projects, Qpia was built using UIKit and the VIPER architecture.

That experience introduced me to a different side of iOS development. I had to understand an existing codebase, follow established architectural patterns, and work with other developers instead of making every decision myself.

Later, I joined the development of KoraTalk, an application initially built with native SwiftUI.

At that point, I expected to continue growing primarily as a native iOS developer.

But the project's requirements changed, and our team made a decision that would significantly influence my engineering career: we were going to rebuild the application in Flutter.

01 / Home — main product areas in the Flutter app
02 / Bookings — browsing sports and venues

2. Why We Decided to Switch to Flutter

KoraTalk already had a native iOS application built with SwiftUI. However, the product needed to become available on Android as well.

One option was to continue developing the existing iOS application and build a separate Android version using Kotlin.

That would allow both platforms to use their native technologies, but it would also mean maintaining two separate mobile codebases.

For a team with limited engineering resources, this was an important consideration.

Every new feature would potentially need to be implemented twice. Fixes might need to be applied separately, and keeping both platforms consistent would require additional coordination.

Our team decided to move to Flutter instead.

The goal wasn't to replace SwiftUI because it was a bad framework. SwiftUI was already doing its job on iOS.

The motivation was primarily a business and development decision: support both iOS and Android without maintaining two independent native implementations.

Flutter offered a shared codebase for most of the application's UI and business logic, while still allowing platform-specific integration when necessary.

At first, I was skeptical.

I had invested considerable time learning Swift and the Apple ecosystem. Moving to Flutter meant learning Dart, a different UI framework, a new state-management approach, and a different set of development tools.

But it also gave me an opportunity to understand mobile engineering beyond a single platform.

3. Rebuilding a Production App From Scratch

We didn't gradually convert individual SwiftUI screens into Flutter widgets.

Instead, we started a new Flutter application from scratch while the original SwiftUI application remained in production.

This was an important part of the migration strategy. We could continue supporting the existing application while developing its cross-platform replacement.

We could build on established services and integrations instead of creating every technical dependency from the beginning.

We weren't starting with an entirely new product. The app already existed, its key flows were defined, and we had a much clearer understanding of what needed to be rebuilt.

In terms of elapsed development time, the Flutter rewrite moved roughly 6× faster than the original native build.

Android was released when the cross-platform implementation was ready.

That result sounds impressive, but it needs context.

It would be misleading to treat this as proof that Flutter itself is 6× more productive than SwiftUI.

The original build involved discovering and refining the product, while the rewrite benefited from existing functionality, design decisions, and lessons learned.

We had much more information about what we were building.

Nevertheless, the rewrite demonstrated something important to me: when the product's requirements are already understood, a shared mobile codebase can make implementation across multiple platforms more practical.

My role in the migration

The migration was led by a senior developer who established the Flutter architecture.

My responsibility was to work within that architecture and implement several application modules, including:

  • Subscriptions
  • Bookings
  • User Profile

As the project progressed, I also became more involved in code reviews and application releases.

This was an interesting transition for me. I wasn't only learning a new programming language; I had to understand architectural decisions made by another engineer and apply them consistently across different features.

It taught me that working effectively within an established architecture is just as important as being able to design one.

4. From MVVM to Flutter State Management

One of the biggest technical changes was how we structured application logic and managed UI state.

Our native iOS application used:

  • SwiftUI for building interfaces
  • MVVM for organizing presentation logic
  • Coordinator for navigation
  • Moya for networking

In Flutter, we used:

  • Flutter widgets for interfaces
  • BLoC in parts of the app, alongside ViewModel-based features
  • GoRouter for navigation
  • Dio for HTTP networking

The libraries were different, but the more interesting change was how I approached state management.

How I worked with MVVM

In SwiftUI with MVVM, I was used to having a ViewModel that exposed properties representing the current UI state.

The view observed those properties and updated when they changed.

For example, a ViewModel could expose a loading flag, fetched data, and an error message. When an asynchronous operation finished, the ViewModel updated its properties, and SwiftUI reacted to the changes.

I found this approach intuitive because it was closely connected to SwiftUI's declarative programming model.

How BLoC changed my thinking

With BLoC, I had to become more explicit about how user actions led to state changes.

A Bloc receives events, handles the relevant operations, and emits states that the UI can react to.

For a feature implemented with Bloc, a simplified interaction might look like this:

User action → Bloc event → Business operation → New state → UI update

Depending on the result, a Bloc-driven screen might show a loading indicator, data, a success state, or an error.

The important part is that the UI reacts to the state produced by the Bloc rather than directly managing the entire operation.

The BLoC ecosystem also provides Cubit, which uses method calls rather than events to produce new states. This is an important distinction: not every component needs the event-based approach.

To be clear, MVVM can also support unidirectional data flow and explicit state modeling. These concepts aren't exclusive to Flutter.

For me, the difference was mostly in how our particular projects organized these responsibilities.

The main lesson was that state management isn't just about choosing a library. It's about making the relationship between user actions, business logic, and UI updates understandable.

This became especially relevant when working on features involving multiple asynchronous operations.

About the examples below

These Dart examples were written specifically for this article using fictional catalog data. They demonstrate common ViewModel, Bloc, and asynchronous loading patterns; they are not copied or adapted from KoraTalk source code. The project involved more than one state-management approach.

catalog_view_model.dartILLUSTRATIVE · DART
import 'package:flutter/foundation.dart';

class CatalogViewModel extends ChangeNotifier {
  CatalogViewModel(this._repository);

  final CatalogRepository _repository;

  List<CatalogItem> items = [];
  bool isLoading = false;
  String? error;

  Future<void> loadItems() async {
    isLoading = true;
    error = null;
    notifyListeners();

    try {
      items = await _repository.fetchItems();
    } catch (_) {
      error = 'Unable to load items';
    } finally {
      isLoading = false;
      notifyListeners();
    }
  }
}
A ChangeNotifier-style ViewModel with injected data access and explicit loading/error state.
Compare with Bloc and an async loading example
catalog_bloc.dartILLUSTRATIVE · DART
import 'package:bloc/bloc.dart';

sealed class CatalogEvent {}
final class CatalogRequested extends CatalogEvent {}

sealed class CatalogState {}
final class CatalogLoading extends CatalogState {}

final class CatalogLoaded extends CatalogState {
  CatalogLoaded(this.items);

  final List<CatalogItem> items;
}

final class CatalogFailed extends CatalogState {}

class CatalogBloc extends Bloc<CatalogEvent, CatalogState> {
  CatalogBloc(CatalogRepository repository)
      : super(CatalogLoading()) {
    on<CatalogRequested>((event, emit) async {
      emit(CatalogLoading());

      try {
        final items = await repository.fetchItems();
        emit(CatalogLoaded(items));
      } catch (_) {
        emit(CatalogFailed());
      }
    });
  }
}
The same illustrative loading operation modeled as an event-to-state Bloc.
independent_requests.dartILLUSTRATIVE · DART
import 'dart:async';

// Illustrative example with fictional services.
Future<DashboardData> loadDashboard(DashboardApi api) async {
  final (items, categories) = await (
    api.fetchItems(),
    api.fetchCategories(),
  ).wait;

  return DashboardData(
    items: items,
    categories: categories,
  );
}
Independent requests can execute concurrently. This example has no KoraTalk-specific logic.

5. Building Features With More Complex Business Logic

Among the Flutter modules I worked on, Subscriptions was the most challenging.

03 / Subscription checkout — purchase confirmation, plan terms and payment action

It wasn't just a screen displaying a subscription plan and a purchase button.

The module involved payment-related functionality, booking-related steps before QR scanning, and QR-scanning functionality.

Compared with simpler profile screens, these features required more attention to how different operations and user interactions fit together.

A payment-related screen, for example, cannot be treated like a simple static interface. The application needs to account for asynchronous operations and different possible outcomes.

A user might initiate an action, wait for a response, encounter an error, or complete the operation successfully.

The UI needs to represent those situations clearly.

Working on these flows encouraged me to think more carefully about loading, success and error states instead of focusing only on individual widget updates.

Another important consideration was keeping responsibilities separated.

The UI should describe what the user sees and how they interact with it. The state-management layer should coordinate the operations necessary to produce the next state. Networking code should remain separate from presentation concerns.

This separation isn't unique to Flutter, but implementing real features in an unfamiliar architecture made these principles more concrete for me.

I started paying more attention to questions like:

  • What happens if a request fails?
  • What state should the interface display while an operation is running?
  • Which part of the application should decide what happens next?
  • How can another developer understand this flow without reading the entire feature?

These questions are relevant whether an application is written in Swift, Dart, Kotlin, or another language.

6. The Hardest Part: Reproducing the Native iOS Experience

One of my favorite things about native iOS development is how naturally SwiftUI works with Apple's design system.

When building native applications, many system components and visual behaviors are available through the platform's own frameworks.

Flutter takes a different approach.

Rather than relying entirely on native UI components, Flutter renders its interfaces through its own rendering system.

That gives developers considerable control over the appearance of their applications and helps maintain consistency across platforms.

However, it also creates challenges when trying to reproduce platform-specific design details.

The Liquid Glass challenge

One challenge we encountered was recreating the native iOS glass effect in Flutter.

We wanted to preserve the visual experience on iOS rather than simply use a completely different-looking interface.

In SwiftUI, Apple's native design APIs provide access to system-integrated visual effects.

In Flutter, we needed another solution.

We used the liquid_glass_renderer package, which recreates Liquid Glass-like effects through Flutter's rendering system.

This avoided having to implement the entire visual effect ourselves.

However, there is an important distinction between reproducing the appearance of a native effect and using the actual native system component.

A Flutter-rendered glass effect isn't automatically identical to Apple's own implementation.

And visual similarity is only one consideration. When using effects involving blur, transparency, and rendering layers, developers also need to consider performance and behavior on real devices.

This experience reinforced an important point for me:

A shared codebase doesn't mean every platform should have exactly the same implementation or appearance.

Sometimes it makes sense to share almost everything. Other times, preserving the expected experience on a particular platform requires additional work.

Flutter offers cross-platform development, but platform-specific UI details still require engineering attention.

7. What I Liked About Flutter

Despite the challenges, I found several aspects of Flutter particularly useful.

Hot Reload

Hot Reload quickly became one of my favorite features.

Being able to modify a widget and see the result without restarting the entire application made UI development feel much more interactive.

It was especially useful when adjusting layouts, spacing, typography, and other visual details.

Of course, Hot Reload doesn't apply every possible code change, and it doesn't replace testing.

But it made many small development iterations faster and more convenient.

One codebase for two platforms

The second major advantage was having most of the mobile implementation in a shared codebase.

Instead of implementing a feature independently for iOS and Android, the same Flutter feature could serve both platforms.

This doesn't eliminate platform-specific work, but it reduces the need to duplicate large parts of the application.

For a relatively small team trying to support both platforms, that was a meaningful benefit.

A different perspective on architecture

Learning BLoC, GoRouter, and Dio also expanded my understanding of how mobile applications can be structured.

I became more comfortable moving between different architectural patterns and recognizing that similar engineering problems can have different implementations.

The concepts I learned in native iOS—separation of concerns, asynchronous programming, networking, navigation, and state management—were still relevant.

Only the tools and some of the implementation details had changed.

8. What I Would Do Differently

Looking back, I think there are several important things developers should consider before migrating an existing mobile application.

1. Understand the business reason before choosing the framework

A migration shouldn't start with the question, "Which framework is better?"

It should start with questions like:

  • Why do we need to migrate?
  • What problem does the current architecture create?
  • How many platforms must we support?
  • What engineering resources do we have?
  • What will the migration cost in development and maintenance?

For KoraTalk, Android support and the cost of maintaining separate implementations were central considerations.

A different product with different requirements might benefit more from staying fully native.

2. Define what must remain consistent

When rebuilding an existing application, it's important to identify which behaviors users already depend on.

This includes more than matching screens visually.

Navigation, loading states, error handling, payment-related flows, and platform-specific behavior all contribute to the user experience.

A migration plan should account for these areas rather than treating the project as a collection of screens that need to be recreated.

3. Don't underestimate platform-specific design

Cross-platform frameworks are powerful, but not every native feature has an identical cross-platform equivalent.

The Liquid Glass challenge was a reminder that visual requirements can introduce additional complexity.

Before committing to a particular design, I would investigate whether the required effects and behaviors can be implemented reliably with the chosen technology.

4. Treat speed comparisons carefully

The rewrite accelerated delivery, but that alone does not explain why.

But the comparison needs context.

Established product requirements, familiar user flows, and lessons from an earlier implementation can dramatically reduce the uncertainty involved in a rewrite.

I would avoid using this project-specific comparison to make broad claims about framework performance or developer productivity.

What matters is understanding why a particular approach was effective for a particular team.

9. Final Thoughts

When I first started learning iOS development, I was focused on becoming a better Swift developer.

I spent a lot of time learning SwiftUI, UIKit, and Apple's frameworks because I wanted to build high-quality native applications.

Moving to Flutter initially felt like stepping away from that direction.

But after working on the KoraTalk migration, I started seeing it differently.

The most important things I had learned through native development didn't disappear when I switched languages.

I still needed to understand architecture, manage asynchronous operations, build reliable features, debug problems, and make decisions based on product requirements.

Flutter introduced a different set of tools, but many of the engineering principles remained the same.

I still appreciate native iOS development, especially its deep integration with the Apple ecosystem. At the same time, I understand why Flutter can be a practical choice for teams that need to deliver an application on multiple platforms with limited resources.

If there's one lesson I took away from this experience, it's that being a good mobile engineer isn't about defending one framework. It's about understanding the trade-offs and choosing the approach that makes sense for the product and the team.

That is something I probably wouldn't have understood as clearly if I had stayed entirely within the iOS ecosystem.

Article 001 · 2,427 words↑ Back to articles
04 / My process

AI-native. Engineer-led.

I use AI agents to move faster, but keep product decisions, verification, and responsibility for the result in my hands.

01 — FRAME

Define

Clarify the problem, users, requirements, and the smallest useful result.

02 — BUILD

Prototype

Use Cursor, Codex, and LLM APIs to turn plans into working software.

03 — VERIFY

Challenge

Read the generated code, test edge cases, investigate logs, and fix failures.

04 — SHIP

Deliver

Deploy, measure what works, and iterate instead of polishing indefinitely.

05 / Experience

Built in real teams.

Aug 2024 — Nov 2026

Mobile Developer

Apricus · Astana

Commercial Flutter and iOS development; KoraTalk mobile features and cross-platform migration, API integration, debugging, and collaboration with product, backend, and QA teams.

Nov — Dec 2023

iOS Developer Intern

Qpia

Native iOS engineering and backend integration; delivered a technical presentation to the engineering team.

Sep 2021 — Jan 2022

Game Design Tutor

Algorithmics

Taught practical game design to young learners and helped students develop projects—experience that also shaped how I explain complex technical topics.

2019 — 2024

BSc Computer Science

Nazarbayev University

Strong computer science foundation. Based in Astana; working languages: English (C1), Russian (C2), and Kazakh (native).

06 / Toolkit

Across the stack.

My strongest foundation is mobile engineering; I use the broader web and AI stack to build complete product experiments.

Native Apple

Swift · SwiftUI · UIKit · Combine · async/await · TCA · XCTest

Flutter

Dart · BLoC/Cubit · GoRouter · Dio/Retrofit · Clean Architecture · GetIt

Web & backend

TypeScript · Next.js · React · Python · REST APIs · PostgreSQL · Supabase

Generative AI

OpenAI API · Higgsfield API · Structured Outputs · AI product workflows

Developer workflow

Cursor · Codex · Claude · Git · Sentry · Railway · Vercel

Product delivery

Prototyping · Code review · Testing · Debugging · Deployment · UX iteration

Also contributed to KNUS ActiveAge ↗, a published iOS application.
07 / Let's talk

Have a product that needs someone who can build?

I'm interested in native iOS, Flutter, AI product engineering, and thoughtful teams that ship. Open to remote opportunities and relocation discussions.