At Grisu Studio, we’ve worked with virtually every major mobile development framework available today. From SwiftUI and Jetpack Compose to Flutter and React Native, we’ve shipped production apps using each technology. After extensive real-world experience, we’ve standardized on React Native with Expo for our utility and hyper-casual applications. Here’s why.

The Evolution of Expo’s New Architecture

Expo has undergone significant improvements in recent years, particularly with its new architecture and development workflow. The framework now offers a compelling balance between developer experience and production capabilities that wasn’t possible in earlier versions.

What Makes the New Architecture Different

The new Expo architecture introduces several key improvements:

• Enhanced Performance: Better startup times and smoother animations through the new React Native architecture
• Improved Native Module Integration: Easier access to native APIs without ejecting
• Better Development Experience: Fast refresh that actually works consistently
• Production-Ready Builds: No compromises on app quality or capabilities

These improvements address the historical criticisms of Expo while maintaining its core advantage: rapid development.

Our Workflow: Manual Prebuild for Maximum Control

While Expo Cloud (EAS Build) offers convenience, we deliberately chose a different path. At Grisu Studio, we use manual prebuild workflows with a specific command:

pnpm expo prebuild --clean

This approach gives us several critical advantages.

Why Manual Prebuild?

Complete CI/CD Flexibility

By generating native projects locally, we maintain full control over our build pipeline. This means we can integrate with any CI/CD system on the market:

• GitHub Actions
• GitLab CI
• Jenkins (our preferred choice for complex workflows)
• Bitrise
• CircleCI
• Custom internal solutions

The manual prebuild approach ensures we’re never locked into a specific build service or vendor.

Transparency and Debugging

When issues arise (and they always do in mobile development), having direct access to the generated iOS and Android projects is invaluable. We can:

• Inspect generated native code
• Add custom native modules when needed
• Debug platform-specific issues
• Optimize build configurations
• Implement custom signing procedures

Cost Control

Expo Cloud services come with usage-based pricing. For a studio shipping multiple apps with frequent builds, manual builds on our own infrastructure provide better cost predictability and control.

Jenkins Integration

Our Jenkins pipelines handle the complete build workflow:

pipeline {
    agent any

    stages {
        stage('Install Dependencies') {
            steps {
                sh 'pnpm install'
            }
        }

        stage('Prebuild') {
            steps {
                sh 'pnpm expo prebuild --clean'
            }
        }

        stage('Build iOS') {
            steps {
                sh 'cd ios && xcodebuild ...'
            }
        }

        stage('Build Android') {
            steps {
                sh 'cd android && ./gradlew assembleRelease'
            }
        }
    }
}

This approach gives us complete control over every step of the build process, from dependency installation to final artifact generation.

The React Native Advantage for Our Team

Beyond Expo’s tooling, React Native itself offers unique benefits for Grisu Studio’s development approach.

Seamless Frontend Developer Transition

Many developers on our team have strong React backgrounds from web development. React Native allows them to leverage existing knowledge:

• Same component model and hooks
• Familiar debugging tools
• Shared patterns and practices
• Minimal learning curve

This means we can move developers between web and mobile projects without significant retraining, maintaining team flexibility and productivity.

TypeScript Integration Across the Stack

We build backends primarily in TypeScript and Go. React Native with TypeScript enables us to share type definitions across the entire stack:

// Shared types package
interface UserProfile {
  id: string;
  username: string;
  preferences: AppPreferences;
}

interface AppPreferences {
  theme: "light" | "dark";
  notifications: boolean;
}

// Used in Go backend (via generated types)
// Used in TypeScript API
// Used in React Native frontend

This shared type system dramatically reduces bugs and improves development velocity. Changes to API contracts are immediately reflected across frontend and backend codebases.

Go Backend Integration

For our Go backends, we generate TypeScript types from Go structs:

// Go backend
type UserProfile struct {
    ID          string         `json:"id"`
    Username    string         `json:"username"`
    Preferences AppPreferences `json:"preferences"`
}

Tools like tygo automatically generate corresponding TypeScript interfaces, ensuring type safety from database to UI.

Rapid Development for Design-Focused Apps

Grisu Studio specializes in design-focused utility apps and hyper-casual games. Our products prioritize:

• Beautiful, intuitive interfaces
• Smooth animations and transitions
• Quick iteration on visual elements
• Fast time-to-market

React Native excels in these areas.

Hot Reload and Fast Refresh

The development cycle in React Native is exceptionally fast:

1. Make a change to UI code
2. Save the file
3. See the change instantly on device

No recompilation, no app restart, no lost state. This rapid feedback loop is crucial when fine-tuning animations, layouts, and interactions.

Rich Component Ecosystem

React Native’s massive ecosystem provides pre-built components for virtually everything:

• Gesture handlers
• Animations (Reanimated)
• Navigation
• UI libraries (React Native Paper, NativeBase)
• Charts and data visualization

This allows us to focus on what makes our apps unique rather than rebuilding common functionality.

Cross-Platform Styling

While we occasionally need platform-specific code, 95% of our styling works identically on iOS and Android:

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: "#FEE9D7", // Grisu cream
    padding: 20,
  },
  button: {
    backgroundColor: "#E2434B", // Grisu red
    borderRadius: 12,
    padding: 16,
  },
});

This shared styling dramatically reduces development and maintenance time.

Comparing Alternatives: Native, Flutter, and Others

We didn’t choose React Native lightly. Here’s how it compares to the alternatives based on our real-world experience.

Framework Comparison Table

Framework	Development Speed	Performance	Team Flexibility	Code Sharing	Learning Curve
React Native + Expo	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Native (Swift/Kotlin)	⭐⭐	⭐⭐⭐⭐⭐	⭐⭐	⭐	⭐⭐⭐
Flutter	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐
Xamarin/.NET MAUI	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐
Ionic/Capacitor	⭐⭐⭐⭐⭐	⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐

Detailed Framework Analysis

Native Development (SwiftUI + Jetpack Compose)

Aspect	Rating	Notes
Performance	⭐⭐⭐⭐⭐	Maximum performance, direct platform access
Development Speed	⭐⭐	Separate codebases for iOS and Android
Cost	💰💰💰💰	Requires two specialized teams
Best For	Complex apps, platform-specific features

When We Use It: We reserve native development for apps requiring cutting-edge platform features or maximum performance. For most utility apps and games, the overhead isn’t justified.

Flutter

Aspect	Rating	Notes
Performance	⭐⭐⭐⭐⭐	Near-native performance with custom engine
Development Speed	⭐⭐⭐⭐	Fast with hot reload
Ecosystem	⭐⭐⭐	Growing but smaller than React Native
Best For	Teams without React experience

Our Experience: We’ve shipped successful apps with Flutter. It’s a solid choice, but Dart’s smaller ecosystem and our team’s React expertise made React Native a better fit for our workflow.

Xamarin / .NET MAUI

Aspect	Rating	Notes
Performance	⭐⭐⭐	Good but heavier runtime
Development Speed	⭐⭐⭐	Moderate with Visual Studio
Ecosystem	⭐⭐⭐	Strong C# ecosystem
Best For	.NET enterprise teams

Our Assessment: Solid for enterprise teams already invested in Microsoft’s ecosystem, but not ideal for our use case.

Ionic / Capacitor

Aspect	Rating	Notes
Performance	⭐⭐	WebView limitations
Development Speed	⭐⭐⭐⭐⭐	Very fast with web tech
Native Feel	⭐⭐	Can feel less native
Best For	Content-heavy, simple apps

Our Assessment: Suitable for content-heavy apps but doesn’t meet our quality bar for interactive applications.

The Sweet Spot: React Native for Our Use Case

After evaluating all options, React Native with Expo hits the perfect balance for Grisu Studio:

Development Speed

We can prototype, iterate, and ship faster than any alternative. For hyper-casual games and utility apps where time-to-market matters, this is crucial.

Code Sharing

Sharing logic, types, and even some UI components with our web properties maximizes developer efficiency.

Team Flexibility

React developers can contribute to mobile apps immediately, and mobile developers can help with web projects when needed.

Quality Output

Our apps meet Apple and Google’s quality standards. Users can’t tell they’re not native apps.

Maintenance Burden

A single codebase means bug fixes and features deploy to both platforms simultaneously.

Platform-Specific Considerations

React Native doesn’t mean ignoring platform differences. We embrace platform conventions:

import { Platform } from "react-native";

const styles = StyleSheet.create({
  header: {
    paddingTop: Platform.select({
      ios: 44, // iOS status bar
      android: 24, // Android status bar
    }),
  },
});

We use platform-specific components when appropriate and follow each platform’s Human Interface Guidelines and Material Design principles.

Performance in Production

The proof is in production metrics. Our React Native apps achieve:

• 60fps animations consistently
• Sub-second cold start times
• Minimal memory footprint
• Battery usage comparable to native apps

These metrics match or exceed our previous native applications for the same functionality.

Challenges We’ve Overcome

React Native isn’t perfect. We’ve encountered and solved several challenges:

Native Module Integration

Some third-party SDKs require custom native modules. Our manual prebuild workflow makes this straightforward.

Build System Complexity

iOS and Android builds can be complex. Our Jenkins pipelines standardize and automate the process.

Dependency Management

npm/pnpm dependency trees can be large. We use workspace configurations and careful dependency auditing.

Platform Fragmentation

Android’s device fragmentation requires thorough testing. We maintain a device lab and use cloud testing services.

None of these challenges were insurmountable, and the benefits far outweigh the costs.

Looking Forward

React Native continues to improve. Upcoming features we’re excited about:

• Further new architecture improvements
• Better debugging tools
• Enhanced performance optimizations
• Improved native module system

Expo’s trajectory is equally promising, with continuous improvements to development tools and build systems.

Conclusion

Choosing a mobile development framework is a critical decision that impacts development speed, app quality, and long-term maintenance. At Grisu Studio, we’ve found that React Native with Expo, using manual prebuild workflows, provides the optimal balance for our needs.

Native development (SwiftUI and Jetpack Compose) offers maximum performance and platform integration but requires duplicate efforts and separate teams. For apps pushing platform boundaries, it’s still the best choice. But for our design-focused utility apps and hyper-casual games, the overhead isn’t justified.

Flutter is a strong contender with excellent performance and beautiful UIs. However, Dart’s smaller ecosystem and our team’s existing React expertise made React Native a more natural fit.

Other alternatives like Xamarin, Ionic, and various hybrid frameworks each have their niches, but none match React Native’s combination of performance, developer experience, and ecosystem maturity.

For studios prioritizing rapid development, code sharing across platforms, and team flexibility, React Native with Expo represents the current state of the art. The manual prebuild approach gives us the control we need for custom CI/CD pipelines while maintaining Expo’s excellent developer experience.

Your mileage may vary based on your team’s expertise, app requirements, and organizational constraints. But for Grisu Studio, React Native has proven to be the right choice, enabling us to ship quality apps like Yak Bak! faster and more efficiently than any alternative we’ve tried.

Technical Stack

If you’re interested in our complete technical stack:

Category	Technology	Purpose
Framework	React Native with Expo	Cross-platform mobile development
Language	TypeScript	Type safety across frontend and backend
State Management	Zustand / React Context	Application state handling
Navigation	React Navigation	Screen navigation and routing
Animations	React Native Reanimated	Smooth 60fps animations
Backend	TypeScript (Node.js) / Go	API services and business logic
Build System	Jenkins	Custom CI/CD pipelines
Testing	Jest, React Native Testing Library	Unit and integration tests
Package Manager	pnpm	Fast, efficient dependency management
Version Control	Git + GitHub	Source code management

This combination has served us well across multiple app launches and continues to be our foundation for future projects.