I think the way to set it up is to have the senior engineers on your RN team be the ones who know everything: they are experts in JavaScript, but they are also comfortable dropping down into Swift/Objective-C and Kotlin/Java when needed. Then you can have junior engineers who are more focussed on the JS side of things (at least to begin with). They key thing here being that the people who can unblock are on the same team as the people who may need to be unblocked and can thus prioritise doing so quickly.
If you need extensive native code for custom modules (we haven't yet needed this at my work) then it would make sense to have native developers on each platform take a lead of that. But there should absolutely be people on your RN team who can do integration work and bug fixing independently of that team.
I think the key is: if you're working with cross-platform tech then you ought to have cross platform developers.
Absolutely, but this speaks to the paradox I think. Cross platform is an attractive choice, precisely when you don't have a such a person. For example, as a solo developer with no native knowledge who wants to ship an app or a small startup hiring their first mobile developer.
Being proficient in all of Web(JS, React), Android(Kotlin, Java, Gradle), and iOS(Swift, Objective-C, CocoaPods) is a pretty significant ask for a single person too. Personally, I check two of those boxes(iOS and Web), adding Android as well would be a bit much.
Hmm... I don't necessarily think it needs to be a single person knowing everything. For example a team made up of you, someone else who knew android and web, and a bunch of people who only knew web would work really well I think. Those who were experts in the native platforms would be responsible for bringing the rest of the team up to speed (providing context, advice, pointing to learning resources, etc).
As someone who came to a react-native project (as the lead) with a web and cordova background and no prior react-native or native platform experience, I've found that just knowing about the ios and android build systems and being able to add basic code to the AppDelegate (ios) and MainActivity (android) has been entirely sufficient for our needs. It would be different if we needed custom native modules (although I'm confident I could learn - I think learning something specific like that would be easier than trying to work out how to structure a whole native app), but then the react-native ecosystem is pretty broad these days. A lot of things are covered.
I’ve shipped a number of RN apps for my current and previous company. I guess I don’t know the extent of what some companies are doing with RN but every time I hear about having to dive deep into Native Modules for their app I always wonder what in the hell they are doing.
The react native ecosystem is huge so you really have to have some domain knowledge to be good at it in my opinion. I’ve read articles where the author was in Native Module hell and I just thought “oh well they could have just used this great package”. I know that illustrates a major problem with RN, but its exactly the type of domain knowledge that will make of break your RN experience.
Yeah I agree. I used to try and be good at all three but dropped android and now just focus on web and iOS (for both day job and hobby stuff). Keeping up with android wasn’t fun for me anymore
This is how we setup our teams for React-Native projects. We usually will have the lead for either-or of the Android/iOS teams also be familiar with that platform.
For example myself: I was the co-lead for 2 React-Native projects at my company along with a dev who is very familiar with Swift/Obj-C. I'm still much more familiar with JS/TS-land but I was one of the few on the team fairly comfortable dropping into native Kotlin/Java for when we needed to.
This worked out well for us. The native iOS dev who worked along with me was less experienced at React/JS/TS itself so I took most of the shot calling for that but having him there for native-iOS help definitely pushed us through points where we would have hit a roadblock for a fairly large project. In the end we had 200k LOC on the React-Native side, and a fairly large amount for both in native due to a large feature that required us to drop into native.
If you need extensive native code for custom modules (we haven't yet needed this at my work) then it would make sense to have native developers on each platform take a lead of that. But there should absolutely be people on your RN team who can do integration work and bug fixing independently of that team.
I think the key is: if you're working with cross-platform tech then you ought to have cross platform developers.