I've been building Trendoline for a few months now. It's a social media app, which means it needs to work on iOS, Android, and have a backend that handles all of it. There's one engineer on the technical side: me.
This forced some decisions early. Here's how it's going.
Why Xamarin
The obvious question is why not just build native for both platforms. The answer is time. Building and maintaining two separate codebases in Swift and Java would have doubled the work on every feature, every bug fix, every screen. With one person that's not realistic.
Xamarin lets you write C# and share most of the business logic and data layer between platforms. The UI layer still needs platform-specific work, but the core of the app runs from a shared codebase. Microsoft acquired Xamarin last month, which is either a good sign for the ecosystem or a reason to worry depending on who you ask. I'm treating it as a good sign.
What actually shares and what doesn't
In practice, roughly 70% of the code is shared. The networking layer, data models, local storage, and most of the application logic all live in a shared project. Platform-specific code is mostly UI components, navigation patterns, and anything that touches native APIs directly.
The platforms differ more than you'd expect at the UX level. Gestures that feel natural on iOS feel wrong on Android. Navigation flows that make sense on one platform confuse users on the other. Sharing code is fine. Sharing user experience decisions is a mistake.
The backend
I went with ASP.NET on Azure, mostly because it integrates cleanly with the Xamarin toolchain and the BizSpark credits make Azure essentially free for now. The API is REST, nothing unusual. Real-time features use SignalR for the live feed.
The architecture is straightforward. I'm not trying to build for scale I don't have yet. One server, one database, deploy when the tests pass.
What's hard
Debugging across three projects simultaneously is the main pain. A bug can live in the shared code, in the iOS-specific layer, or in the Android-specific layer, and finding which one takes longer than it should. The tooling is improving but it's not great yet.
Also, context switching between C# backend and Xamarin UI work in the same day is tiring in a way that's hard to explain. The mental models are different enough that you lose flow constantly.
What's working
The speed of iteration is genuinely good. Adding a feature once and having it show up on both platforms immediately is satisfying. I can move fast in a way that wouldn't be possible if I was maintaining two separate codebases.
We're close to a first testable version. More on that soon.
With gusto, Fatih.