Building Mobile Apps Backed with Python

Episode Deep Dive

Guests Introduction and Background

Loren Aguey – Transitioned from live sound engineering to coding in 2020. Now a Flutter expert, Loren has shipped multiple production apps for iOS and Android, often using Python (FastAPI) to handle backends and real-time notifications.

Michael – While often the host of Talk Python To Me, Michael also joins as a panelist. He has extensive experience in Python training, web development, and tooling around Python. Michael runs Talk Python Training, creating courses and helping teams build robust Python apps and APIs.

Andreas (Sweden) – A Python developer for 10 years, focused on Django-based membership management systems. Andreas has led e-commerce payment solutions, plus mobile and web integrations using Ionic + Angular on top of a Django backend.

Harout – With a background in applied math and data science, Harout focuses on building tools that simplify end-user tasks. He leans on Swift + SwiftUI for a fully native iOS experience, backed by Python for data processing and API services.

Joshua and Jeffren (Colombia) – Developed V3D, a 3D modeling–focused app entirely in Python with Kivy. Passionate about combining 3D design and Python’s libraries, they incorporated GPU rendering, texture mapping, and even Xbox controller support in a single codebase.

What to Know If You're New to Python

If you’re starting out with Python and want to follow the conversation on mobile + Python:

• Have a basic understanding of backend frameworks (e.g., Django, FastAPI) for APIs.
• Know how mobile apps communicate over HTTP requests to retrieve or update data.
• Be familiar with Python’s packaging approach (virtual environments, pip installs).

Here are a few official learning references:

• Python Docs: The official Python language reference.

Talk Python's Courses Mobile App

A significant example in this episode is the Talk Python Training mobile app for iOS and Android, built with Flutter on the front end and powered by a Pyramid (Python) backend. It allows course participants to watch videos, track progress, and even download lessons for offline viewing. Check out Talk Python’s Courses Mobile App to see a real-world demonstration of a Flutter + Python combination in action.

Key Points and Takeaways

1. Where Python Fits in Mobile Development Although not the typical first choice for front-end mobile UIs, Python excels at backends (APIs, data processing). Some frameworks like Kivy even allow complete mobile apps in Python. Depending on your goals, Python can either be the star of the show or a powerful supporting player.
   • Links / Tools:
     • Kivy
     • Django
     • FastAPI
2. Choosing a Mobile Framework or Approach From Ionic (web-based) to Flutter (cross-platform native performance) to full native in Swift + SwiftUI, each path caters to different needs. Whether you prefer all-in Python with Kivy or combining Python on the server side and another language for the UI, the decision depends on in-house expertise and how deeply you need to tap into native APIs.
   • Links / Tools:
     • Ionic
     • Flutter
     • Swift and SwiftUI
3. Backend Architectures and Django Andreas and others highlight Django REST Framework for powering membership management, payment integrations, and user admin. Consolidating many services into a unified Python codebase can simplify development and reduce overhead, rather than juggling multiple microservices.
   • Links / Tools:
     • Django REST Framework
4. FastAPI for Rapid Server Iteration Loren uses FastAPI for the Talk Python mobile app, demonstrating how quickly you can adapt or fix server-side logic without forcing app updates. FastAPI’s efficiency and strong typing features fit well with Flutter’s reactive approach.
5. Pure Python Mobile with Kivy Joshua and Jeffren prove you can build advanced mobile experiences using 100% Python. Kivy features a GPU-accelerated rendering engine, making it suitable for 3D textures and interactive UIs. Built-in support for devices like game controllers shows the library’s range.
6. Cross-Platform vs. Native Tradeoffs Harout adopted SwiftUI for maximum iOS integration but must tackle Android separately if needed. In contrast, frameworks like Ionic or Flutter let developers ship for Android and iOS at once, albeit with some tradeoffs in performance or access to low-level APIs.
7. Offline vs. Online Capabilities For data and media-heavy apps, offline mode may be crucial—storing files in local databases or caching them. For others, it’s simpler to rely on continuous internet access. Each approach has different implications for app design, user experience, and sync logic.
8. Navigating App Store Submissions Panelists note Apple’s strict guidelines, especially around in-app purchases, can cause friction—even if your app doesn’t initially plan to sell content. Adding push notifications or updating app versions requires following specific processes that can delay releases.
   • Links / Tools:
     • Xcode
     • Android Studio

Interesting Quotes and Stories

• Loren on Switching Careers: “My first line of code was at 36. If you stick to it, you can pivot into coding pretty quickly.”
• Harout on Swift: “If I’m going to drop to native code for advanced iOS features, might as well start with SwiftUI from scratch.”
• Andreas on Ionic: “We’re a small team that needed a single codebase for iOS, Android, and web. Ionic just made sense.”
• Joshua/Jeffren on Kivy: “People mistake our app for a game because we use advanced 3D textures, but it’s really just Kivy’s power and Python’s libraries combined.”

Key Definitions and Terms

• Native App – Mobile app built specifically for a platform in its primary language (Swift for iOS, Kotlin for Android).
• Cross-Platform – Write one codebase and deploy to multiple platforms (e.g., Flutter, Ionic).
• Backend / API – The server side responsible for data storage, authentication, and business logic.
• Kivy – A Python framework enabling cross-platform, GPU-accelerated mobile and desktop apps.

Learning Resources

If you’d like to explore the Python server side or full-stack approach:

• Modern APIs with FastAPI and Python: Build performant Python APIs that pair seamlessly with any mobile or web front end.
• Django: Getting Started: Use Django’s built-in features for rapid development, including its ORM and REST framework options.

Overall Takeaway

This episode highlights that Python’s flexibility allows you to build mobile apps in myriad ways—fully in Python using Kivy, or a hybrid approach where Python drives the backend. Each framework (Ionic, Flutter, SwiftUI, Kivy) has its own strengths and tradeoffs, but Python consistently brings speed of iteration, rich libraries, and easy maintainability to the table. By matching the right framework to your goals, you can create robust mobile solutions without sacrificing your comfort in the Python ecosystem.