What to Do When a Potential Client Needs Something Outside Your Tech Stack

Last year, a startup founder I had built two iOS apps for came back with a new project. Great news, except this time they needed an Android version first, with a React Native cross-platform build to follow. That is not what I do. I am a native iOS developer. I write Swift, I think in UIKit and SwiftUI, and my entire tech stack is Apple’s ecosystem.

This situation comes up more often than most freelance app developers want to admit. A client you have a strong relationship with needs something outside your tech stack (cross-platform work, a complex backend, an Android-first build, or a web app), and you have a choice. You can try to fake competence in a technology you do not know well, or you can handle it the way experienced freelancers do: refer the work to someone you trust, keep the client relationship, and potentially earn a referral fee on the project.

I have been freelancing as an iOS developer for about eight years. During that time, I have turned down or referred out dozens of projects that did not fit my skills. Those referrals have not cost me clients. They have actually strengthened my relationships and generated income from work I never would have done myself.

Referring Cross-Platform or Backend Work to Trusted Developers

The instinct when a good client asks for something outside your expertise is to figure out how to do it anyway. That instinct will get you in trouble. Taking on a React Native build when you have never shipped one, or architecting a cloud backend when your experience stops at REST API integration, produces mediocre work and damages the reputation you spent years building.

The smarter move is to be direct with the client and make a referral to someone who specializes in what they need. But there is a right way and a wrong way to do this.

The wrong way: just saying no

If a client asks you to build a cross-platform app and you respond with “sorry, I only do iOS” and leave it at that, you have solved their problem by not solving it. They now have to go find a developer on their own, probably through a marketplace where they will wade through hundreds of profiles with no way to judge quality.

Worse, you have signaled that their problem is not your problem. That client is less likely to come back to you even for iOS work, because you did not help them when they needed it.

The right way: make the introduction

When I get a request outside my tech stack, I tell the client exactly where my expertise ends and who I would recommend for the work. It usually sounds something like this:

“This project is really a React Native build, and I am a native iOS specialist. I do not want to give you B-minus work on something that deserves an A. I know a developer who specializes in cross-platform apps and has shipped several projects similar to yours. Want me to introduce you?”

That response does three things at once. It shows technical honesty, which builds trust. It solves the client’s problem immediately, which builds goodwill. And it keeps you in the loop as the person who made the connection, which keeps the relationship alive.

What types of work to refer out

• Cross-platform mobile development. React Native, Flutter, Kotlin Multiplatform: if the client needs one codebase across iOS and Android and your strength is native Swift, refer it. The frameworks have their own patterns, build systems, and debugging workflows that take real experience to do well.
• Android-first or Android-only builds. Kotlin and the Android SDK are a different world from Swift and UIKit. A client who needs an Android app deserves a developer who thinks natively in that ecosystem, not an iOS developer learning on their dime.
• Backend architecture and cloud infrastructure. Many iOS developers handle basic API integration, but designing and building a scalable backend with authentication, databases, real-time features, and deployment pipelines is a different discipline. If the client needs serious backend work, connect them with a backend specialist.
• Web application development. Some clients start with a mobile app request and then realize they also need a web dashboard, admin panel, or customer-facing web app. Front-end web development with React, Vue, or Angular is its own skill set. Refer it to someone who lives in that world. Web designers build similar referral partnerships from the other side of this same dynamic.

Structuring a Referral Fee When You Pass Along Qualified Leads

When you refer a client to another developer, you are handing them a qualified lead: someone who already has budget, a defined project, and a need. That introduction has real value, and more freelance developers are structuring a referral fee around it.

How referral fees typically work for app developers

In my experience and from conversations with other freelance developers, referral fees in tech freelancing typically fall into two structures:

1. Percentage of project value. The most common arrangement. The developer who receives the referral pays the referring developer a percentage of the total project fee. For app development projects, this usually ranges from 5% to 15%, depending on the project size and the strength of the relationship. On a $40,000 cross-platform build, a 10% referral fee is $4,000 for making an introduction that took you ten minutes.
2. Flat fee per referral. Some developers prefer a fixed amount regardless of project size. This works well when the projects you refer tend to be consistent in scope, for example, $1,000 per qualified lead that converts to a signed project.

Setting up the arrangement before you refer

The time to discuss referral fees is before you make the first introduction, not after. A conversation like this works well:

“I regularly get requests for React Native work that I am not the right fit for. If I send qualified leads your way and they turn into projects, I would want a 10% referral fee. Does that work for you?”

Keep it straightforward. You do not need a ten-page agreement. What matters is that both sides understand the fee percentage or amount, when the fee gets paid (usually after the receiving developer gets their first payment from the client), and what counts as a qualifying referral (typically, a warm introduction to a client with a defined project and budget).

Key details to agree on

• Fee amount or percentage. Be specific. “We will figure it out later” always leads to awkward conversations.
• Payment timing. Most arrangements tie the referral fee to the receiving developer’s first milestone payment from the client. This ensures neither party is out of pocket on a project that has not started.
• Scope of the arrangement. Does the fee apply only to the initial project, or to follow-up work from the same client? Most referral arrangements cover only the first engagement, which keeps things simple. If the referred developer builds a long-term relationship with the client independently, that is their business.
• How to track it. A simple shared record (even a text thread confirming the referral and terms) is enough for most freelancer partnerships. The point is to have something you can both reference, not to create paperwork. If you are looking for something more structured without the overhead, PureIntro is built for exactly this kind of arrangement between tech professionals.

How to Vet Another Developer Before Sending Your Client Their Way

This is the part most freelancers skip, and it is the part that matters most. When you refer a client to another developer, your reputation is on the line. If the developer you recommended does poor work, misses deadlines, or communicates badly, the client does not just blame that developer. They blame you for the recommendation.

I learned this the hard way. Early in my freelance career, I referred a client to a developer I had only interacted with casually in a Slack group. His portfolio looked solid. The project went badly: missed milestones, unresponsive communication, and a final deliverable that needed significant rework. The client never hired me again either.

What to look for before you refer someone

1. You have seen their shipped work firsthand. Not just a portfolio page: actual apps you have downloaded, tested, or reviewed the code for. A polished portfolio site can hide a lot. An app in production with real users and consistent updates tells you what you actually need to know about their craft and reliability.
2. You have worked alongside them. The strongest referrals come from developers you have collaborated with on a real project. You have seen how they handle deadlines, how they communicate when things go wrong, and how they deal with ambiguous requirements. Game jam teammates, open source collaborators, and former colleagues are the best referral partners because you have firsthand evidence of how they work. Indie game developers use this same approach to build referral networks from jam collaborations.
3. You can verify their client references. Ask the developer for one or two past clients you can contact. A developer who is confident in their work will have no problem with this. If they hesitate or refuse, that tells you something.
4. Their communication style matches what your client expects. Some clients want daily standup messages and detailed progress reports. Others want a weekly summary and to be left alone in between. A technically excellent developer with the wrong communication cadence for your client will still create friction. Match the developer’s style to the client’s expectations.
5. They specialize in what the client needs. “Full-stack developer” is not specific enough. Does the client need a React Native specialist or a Flutter developer? A backend engineer who knows AWS, or one who works primarily with Firebase? The more precise the match between the client’s technical requirements and the developer’s actual expertise, the better the outcome.

Building a short list of trusted developers

I maintain a small roster of developers I can refer work to with confidence. Right now that list has six people: one Android specialist, one React Native developer, one Flutter developer, one backend engineer, one full-stack web developer, and one developer who handles DevOps and cloud infrastructure.

Each of these people is someone I have either worked with directly, collaborated with on a side project, or whose shipped apps I have reviewed in detail. I know their rates, their availability patterns, their communication style, and the types of projects they do well.

When a client needs something outside my tech stack, I do not have to scramble. I check my list, match the client to the right developer, and make the introduction within a day.

Maintaining the Client Relationship When Someone Else Does the Work

Here is the fear that stops most freelancers from referring clients out: “If I send my client to another developer, I will lose them.” In my experience, the opposite is true. Clients who you help by connecting them with the right person come back to you more often than clients you try to hold onto by taking work you should not.

But staying connected to the client after someone else takes the project does require some intentionality. You cannot just make the introduction and disappear for six months.

How to stay connected during the referred project

• Make a warm introduction, not a cold handoff. Do not just send the client a name and email. Set up a three-way introduction where you explain the developer’s background, why they are a good fit for this specific project, and offer to answer any questions. That context makes the client feel taken care of, not passed off.
• Check in with the client during the project. A casual message every few weeks (“How is the project going with Alex? Everything on track?”) keeps you visible without being intrusive. If problems come up, you are positioned to help. If things go well, the client associates that positive experience with your recommendation.
• Stay available for your piece of the stack. If the client needed a backend developer for this project but will eventually need iOS work, make sure they know you are ready for that phase. Sometimes I will mention it directly: “Once Alex has the API built, I would love to talk about the iOS app that sits on top of it.”
• Follow up after the project wraps. When the referred project is complete, check in with the client again. Ask how it went, whether they are happy with the result, and what their next priorities are. This touchpoint often leads to the next conversation about work you can do. The follow-up systems I use for past clients work exactly the same way for clients you have referred out.

Why referrals strengthen relationships instead of weakening them

Think about it from the client’s perspective. They come to you with a problem. Instead of taking their money for work you cannot do well, you are honest about your limitations and connect them with someone who can actually deliver. You have just demonstrated something that is rare in freelancing: integrity that puts the client’s outcome above your own short-term revenue.

That kind of honesty builds deep trust. The client now sees you as their go-to person for app development needs broadly, not just iOS specifically. When they need iOS work, they come to you. When they need something else, they ask you who to hire. You become their technical advisor, not just their iOS developer.

I have seen this play out repeatedly. One client I referred to a React Native developer for their first project came back to me six months later for a native iOS companion app. Another client whose backend project I referred out has now sent me three separate iOS projects over the past two years, all because I helped them when I could have just said no.

Putting It Together: A Practical Framework

Here is the framework I follow when a potential client needs something outside my tech stack. It works whether the request is for Android, cross-platform, backend, web, or any other technology I do not specialize in.

1. Be honest immediately. Tell the client what you specialize in and why this project would be better served by someone else. Do not hedge or apologize. Frame it as you looking out for the quality of their project.
2. Recommend a specific developer. Not a vague “you should find someone who does React Native.” Give them a name, explain why that developer is a good fit, and offer to make the introduction.
3. Make the introduction warm. A three-way email or message that gives both sides context: the client’s project summary, the developer’s relevant experience, and your endorsement.
4. Confirm referral terms with the developer. If you have a fee arrangement, confirm the terms before making the introduction. If you do not have one yet, this is the time to set it up.
5. Follow up during and after. Stay visible to the client throughout the project and reconnect when it wraps. Position yourself for the next piece of work that does fit your skills. UX consultants use a similar approach when enterprise projects exceed their solo capacity.

Getting Started: Your First Steps

If you are a freelance app developer who has been turning down projects outside your tech stack without referring them, here is what I would do this month:

1. Identify two or three developers in complementary specialties. An Android developer, a cross-platform developer, a backend engineer. These should be people whose work you have seen or who you have collaborated with, not strangers from a portfolio site.
2. Reach out and propose a reciprocal referral arrangement. Let them know you regularly encounter projects outside your stack, and ask if they would be interested in receiving those referrals with a fee structure attached. Most developers will say yes. A warm lead from a trusted peer is worth far more than whatever percentage they pay for it. Freelance UX consultants have found the same thing with their referral partnerships.
3. The next time a client asks for something outside your stack, refer it. Make the introduction, stay connected with the client, and follow up when the project finishes.
4. Track the outcome. Note which referrals converted, which developers delivered well, and which clients came back to you afterward. That data tells you who to keep referring to and where to invest in new referral partnerships.

Every project outside your tech stack is an opportunity, not a loss. The developers who build sustainable freelance businesses are not the ones who try to do everything. They are the ones who know exactly what they do best, and who have trusted peers to handle the rest.

This post reflects one professional’s experience and is for informational purposes only. It is not business, legal, financial, or professional advice. Results described are individual and not guaranteed. Referral fee arrangements may be subject to state and local regulations. Consult a qualified professional for guidance specific to your situation. PureIntro facilitates referral tracking and payment processing but does not guarantee payments between users or any particular business outcome.