Hire .NET talent in India. We handle the employment.

India's .NET ecosystem is dominated by large services firms and GCC operations in banking, insurance and healthcare, which is both opportunity and screening problem. The headcount exists in abundance, but most of it clustered in maintenance-mode WebForms or ASP.NET Framework 4.x projects inside vendor organizations where the engineer never owned the full cycle from inception through deployment to production support. The .NET developers who work on modern systems, ASP.NET Core, .NET 8, Entity Framework Core and Azure services, are fewer and more costly, concentrated into a distinct layer that commands senior compensation and expects formality. This layering is the source of India's .NET hiring challenge: raw headcount numbers mislead because they conflate the maintenance population with the innovators.

Hyderabad and Chennai punch above their weight in the .NET market in a way they do not for Python or Go. Microsoft's India R&D footprint and the GCC density in financial services and telecom gives both cities an unusually strong concentration of engineers with real .NET fundamentals. Bengaluru and Pune remain large secondaries, and NCR still produces solid mid-market candidates, but the best modern .NET practice sits in the South. If you are building a center of .NET engineering, Hyderabad is worth the deliberate focus. The cost premium is modest and the screening signal is immediate.

The shift from .NET Framework to .NET Core has created a two-tier market that is sharper than most language migrations. Many Indian engineers have years of listed .NET experience but have never written async/await patterns, never worked with dependency injection containers, never deployed a microservice to Kubernetes. The CV screening is deceptive. A technical screen reveals it immediately, which is why the rubric in a later chapter matters so much. An engineer with eight years of .NET can price identically whether they have shipped one modern service or none.

GCC backgrounds are unusually common among .NET candidates. Developers who moved from services firms into Global Capability Centres at banks and insurers bring structure, formal processes and often deeper domain knowledge, but also narrower scope, sometimes working on a single module of a larger system for years. Learning to read the GCC experience is essential: someone who spent three years as an SSE building a message queue in an event-driven architecture is a different hire from someone who was assigned three tickets per sprint inside a larger application. The GCC engineer brings discipline; the question is whether they have owned an end-to-end system.

You are not choosing from an infinite pool. You are choosing from a pyramid where the top thousand or so have genuinely shipped modern .NET at scale, and the next fifty thousand carry degrees and job titles but limited exposure to the actual technology you will ask them to own. The pay compression between the two layers is tighter than in some ecosystems, which is another reason the technical screen is non-negotiable.

Salaries are quoted in CTC, cost to company, in lakhs per annum. One lakh is 100,000 rupees, approximately 1,200 dollars per year at 2026 rates. Here are the live bands clearing in fresh offers, not backfilled survey numbers.

💰 What moves pay inside the band

Azure platform experience adds 20 to 35 percent when the role touches cloud infrastructure, because financial and healthcare firms bid hard for engineers who have lived in that ecosystem. GCC background from a tier-one bank or insurer adds 10 to 20 percent, because domain knowledge and operational discipline carry a premium inside enterprise software. Hyderabad or Chennai zip code adds 15 to 25 percent relative to tier-two cities, reflecting the genuine talent density gap. And active competing offers add whatever they say, because counter-offers are standard and managers know it.

Stretch for the top of the band when budgeting. A mid-level engineer with real ASP.NET Core production work, cloud experience and clean communication costs 14 to 22 LPA in today's market, not the 10 LPA floor. Teams that budget floor and then interview the bottom layer report that India hiring does not work. It works. The floor does not.

Salaries are moving roughly 10 percent annually, with switch increments of 30 to 50 percent common. Check live data at offer time, not from a whitepaper. The salary calculator refreshes from actual closures and tracks .NET bands live.

The offer letter quote hides the employer cost stack, which is the single biggest budgeting mistake first-time India buyers make. Statutory contributions run 12 to 20 percent of CTC depending on how the salary is structured, and ignoring them produces budgets that underrun within three months.

💸 Two costs hiding in plain sight

Foreign exchange spread is the first leak. Regular bank wires cost 3 to 5 percent on the exchange rate, never labeled in the invoice, just absorbed into your wire every month. Settlement at the RBI reference rate eliminates it. Ask vendors their spread rate before signing.

Misclassification is the second and costlier mistake. Treat a full-time .NET developer as a contractor and the invoice reads 15 percent cheaper because contractor invoices fund no PF or gratuity. If that ever gets reclassified, and full-time engineers on your repos almost always do, arrears run backward to day one with 12% annual interest plus damages. The real exposure is 25,000 to 40,000 dollars per person. The contractor discount is debt, not savings.

Run both models through the EOR versus entity calculator before committing budget. For teams under 10 to 15 India hires, EOR is nearly always cheaper than the contractor risk or starting your own entity.

Every channel works in India. None of them work equally. The signal-to-noise ratio dictates your screening cost in hours.

🚀 Sourcing channels in order of credibility

Referrals from engineers already inside modern shops remain the gold standard, but they are usually passive and take time. GitHub activity is stronger for .NET than many assume, because library work, clean tests and proper async code show up clearly in public. LinkedIn targeted outreach, filtering aggressively on recent company and technology keywords, pulls well. Naukri and similar job boards generate hundreds of responses per opening, mostly from services-company backgrounds with shallow modern .NET depth, costly to screen.

The strongest lever is direct outreach to passive engineers. Technical bloggers writing about ASP.NET Core, open-source contributors to the Orleans or Dapr projects, engineers who answered detailed questions on Stack Overflow about .NET concurrency: these people are not job-hunting, which is exactly why they are better hires. A personalized note that demonstrates knowledge of their actual work wins meetings that a forwarded job description never does.

Microsoft's India communities are underexploited. .NET community events, Dot Net Architects forum, and the maintainer circles around libraries like Polly and Serilog hold the people who have invested in the craft. A month of conversation in these spaces teaches more about your market than any recruiter.

⚠️ The agency cost trap

Staffing agencies invoice 8.33 percent of annual CTC at the low end, or charge 15 to 40 percent markup on day rates at the premium end. They screen for keyword matches, not for architecture understanding or modern stack depth. You still do all the real filtering, just with a margin removed from your budget.

Our model runs differently: a technical shortlist against your .NET brief in nine days, screened on modern framework depth, async patterns and code review exercises. Priced at 12 percent of annual CTC for junior and mid roles, 15 percent for senior, due only at day 90 when the hire is retained. Zero fee at offer. If they do not make it through the first quarter, you do not pay. The full sourcing approach is detailed at /recruitment/.

.NET's entry barrier is low and its depth is deep, so the hire spread is wide. The rubric below is our technical screen foundation; it filters for the candidates worth your calendar time. Use it regardless of working with us. The weights matter because they force you to value the right dimensions; an engineer can know SQL well but if their async understanding is shallow, the weight distribution reveals it.

✅ Three signals that predict actual performance

First, the code review exercise on a deliberately flawed pull request shows judgment in 30 minutes and cannot be prepped from study guides. The best signal is whether the candidate spots the real bugs versus the style nits, because that tells you they have reviewed code professionally, not just written it. Second, ask candidates to walk through a system they shipped and push on one architectural choice: people who owned the work defend with detail and reference trade-offs they considered, people near the work fade inside two questions and offer generic explanations. Third, async code is the .NET tell. A candidate who cannot explain when to use Task versus Task.T, or how ContinueWith relates to await, has not shipped modern .NET at meaningful scale. Bonus signal: ask about error handling in async contexts, specifically around AggregateException unwrapping and Task cancellation patterns. Most engineers stumble here.

Calibrate bar to band. A 16 LPA mid-level who scores 70 on this rubric is a solid hire. Demanding 90 at that level means infinite interviewing, and the 90s price at senior money anyway. A senior at 30 LPA should score 80 plus on this rubric. If they do not, the problem is usually depth in one area being compensated by seniority in years rather than actual output.

Speed matters in this market more than polish. A strong .NET engineer is running multiple processes in parallel, and offers land inside two weeks of first contact. A rambling five-round process spread over a month loses people to other offers. The teams that close fast are the ones that prepare the loop in advance, assign interviewers beforehand, and batch candidates through the pipeline together rather than processing one at a time.

⏰ The four-stage close

Stage one, a 30-minute screen on motivation, compensation fit and communication, run by us or your team. This screen is pass or fail, and the questions matter: ask why they are looking, what compensation range they are targeting, and whether they have read your job description enough to speak to the specific stack. Stage two, the technical screen against the rubric, 60 to 90 minutes, drilling async patterns, EF Core query translation and production decisions. This is where most attrition happens; if the candidate does not pass, save everyone's time and move on rather than giving feedback hope. Stage three, your loop: a deep technical conversation with the hiring manager, and one conversation with a peer on architecture or system design thinking. These rounds should drill into past decisions and production issues, not hypotheticals. Stage four, a 30-minute final with founder or values owner. Four touches, under ten days total, decision within 48 hours of final round. Delays kill deals.

Time zones are the execution problem. India is 9.5 to 13.5 hours ahead of US coasts. The windows that work are early US morning, evening in India, and late US evening, early India morning. Batch all interviews into these windows, confirm slots inside 24 hours. Silent days between rounds read as low interest and candidates act on that signal. A one-week silence between stage two and stage three tells the candidate they were not your first choice.

🤔 Counter-offers will come

Expect a counter on resignation day, usually 30 to 50 percent above current pay. Build your defense before the offer stage: ask directly what would keep them, anchor on non-financial reasons they engaged with you, keep the gap between acceptance and start date short. Notice periods make that last part tricky, see next chapter. Some teams also ask about counter-offer mechanics explicitly before the offer stage, learning what freedom the candidate has to negotiate internally.

One important note: Indian .NET engineers, especially GCC backgrounds from banks, evaluate the entire structure of the offer holistically. Whether PF is included, whether it is a variable component and how believable it is, whether your payslip is from a registered Indian entity, whether health insurance covers family members. A contractor invoice arrangement gets heavily discounted by senior people because it breaks their loan eligibility, their visa documentation and their PF continuity. Formal employment is not just compliance; it is part of your offer's strength and your competitiveness in the market.

A US offer typically means a start date in two weeks. India contracts contain written notice periods of 30 to 90 days, enforced by current employers, and 60 days is the practical median for mid and senior engineers. Every India hiring plan must absorb this, and no vendor honestly makes it vanish.

⏳ Two levers that shorten the timeline

Buyout is the first. Many Indian employers permit salary in lieu of unserved notice, and new employers conventionally fund it. Buying down a 60-day notice to 30 costs one month of gross salary, a few thousand dollars for a mid-level .NET engineer. Worth it if the seat is unblocking roadmap work; not worth it as routine.

Planning depth is the second and better lever. Start searches 60 to 90 days before you need someone shipping code, and the notice period becomes part of your ramp-in instead of a crisis. Teams that plan India hiring like US hiring experience every notice period as a surprise. Teams that plan correctly do not.

One flag: a candidate available to start tomorrow is a yellow signal at mid and senior level. It means already resigned, benched, or between roles for reasons worth exploring. The top people are employed and serving notice. The 60 days means they are in demand, not that you are stuck in a process.

Do you own the code? Yes, provided the paperwork is built correctly. Indian law respects IP assignment, but the assignment must exist in a contract governed by Indian law between you and the person's actual employer.

🧾 What has to be in the contract

Four clauses carry the work. A present-tense IP assignment clause, covering work product, not conditional assignment that happens later. A confidentiality clause that survives the employment end. A waiver of author moral rights, required under Indian copyright law which vests those rights in code contributors unless explicitly surrendered. And non-solicitation language that is actually enforceable, since Indian courts routinely reject broad non-competes after employment ends. Build your protection around IP and confidentiality; do not rely on non-competes.

The structural point: a US-law contractor agreement signed with an Indian independent contractor is a thin shield because enforcement runs through Indian courts anyway, and the contractor relationship itself is the misclassification exposure from chapter three. When employment is through a registered Indian entity, the IP assignment sits in an Indian employment contract, enforceable where the person lives, with clean employment underneath.

This is where the EOR earns the fee on something other than payroll. Under our structure the developer is employed by our registered Bengaluru entity with present-tense IP clauses built into the standard contract, and a parallel agreement assigns all work product to you. Our EOR service in India runs on templates drafted for Indian law from the ground up, not adapted from global boilerplates after.

Layer in operational security: repos under your org, device policy in writing, access revocation wired to exit. Contracts are the backstop; access control is the daily protection.

Entity onboarding on our registration runs five business days flat. Day one covers KYC and bank verification. Day two clears UAN and PF enrollment. Day three provisions development machines and full repo access with Azure DevOps permissions. Day four completes compliance and security induction. Day five initiates the first payroll cycle. Building your own entity stretches to four to six months; the step-by-step guide is in the hiring manual.

🧾 The statutory payroll calendar

Indian payroll follows a fixed compliance rhythm. TDS, withheld income tax, due by the 7th of the following month. PF and ESI contributions due by the 15th. Professional tax varies by state, Karnataka expects it monthly. Quarterly TDS returns, annual PF reconciliation, Form 16 issuance stack on top. Every miss accrues interest and penalties. Every filing vanishes into your EOR's backoffice, which is the whole point.

Salaries are paid monthly, almost always last working day or 1st of month. Your .NET engineer expects an itemised payslip showing gross, PF, TDS and net. Payslips matter deeply: landlords, banks and visa officers all ask for them. A vendor that cannot produce clean payslips is running transfers, not payroll.

📅 The integration layer

Flawless payroll can still be undercut by poor integration. Set explicit written goals for day 30, day 60 and day 90. Pair your .NET engineer with a senior engineer from your core team who owns the architecture and code review process. Guard two to three hours of daily overlap for pairing, code review and live decision-making, plus one structured weekly one-on-one. .NET engineers in remote centers founder from isolation and decision uncertainty far more often than from technical shortfall.

Indian tech attrition is 15 to 20 percent per year, and a sharp .NET engineer receives recruiter messages weekly. Losing a ramped engineer costs the search, the notice period, the ramp again, six months of compounding loss. Retention is the real cost centre of India teams.

🔁 Four practices that move retention

Pay inside the band, benchmarked annually against live offers rather than against your home market, because a 10 percent below-market drift becomes a resignation letter. Give genuine ownership: engineers who own services stay, engineers handed tickets leave, and this single thing matters more than the rest. Make the person visible, in demos, in architectural decisions, in the room where the roadmap is decided. And run the basics right: salary on time every month, PF filed, insurance active, expenses reimbursed without chasing. Teams with erratic payroll lose people and never learn why.

What money cannot fix is a bad manager at headquarters who treats India engineers as execution resources. Candidates talk to each other. Your reputation inside the .NET community in Hyderabad or Bengaluru is set in two hires. Win the talent market by being the company whose first hires recommend friends.

Statutory employment also anchors people. Continuous PF history, gratuity building toward the five-year cliff, formal payslip trail: these anchor financial life in ways invoices never do. Properly employed people have stronger reasons to stay.

Plan for some attrition anyway because the market is hot. Keep bus factor above one on every service, treat documentation as part of done, and manage resignations as 60-day handover projects. Teams that do this lose a person and rarely lose momentum. Teams that concentrate knowledge in one person are betting the roadmap on chance every year.

Perfect payroll does not guarantee perfect performance. The teams that get compound value from India engineers operate three to four deliberate practices that are boring to set up and transformational once they are running. The difference between a high-performing India team and a low-performing one is almost never capability; it is structure.

🕐 Overlap is a design choice

Lock in two to three hours of daily overlap and protect it like a customer meeting. For US East, that is early morning Eastern, evening in India. For UK teams, overlap is generous, most of the Indian afternoon. Put standups, pairing and decisions inside the overlap window; heads-down work outside. Default everything else to writing: decision logs, PR descriptions that carry context, recorded demos, RFCs in Slack that people can read async. A codebase with typed interfaces and honest docstrings is itself an async communication tool, and engineers who score well on the written screen from earlier chapters also thrive here. The teams that build compound value from India are the ones where async is not an excuse but a design principle.

🌴 Leave, holidays and working calendar

Indian employment norms include 18 to 24 days paid leave plus roughly 10 state-specific public holidays. Karnataka's holidays differ from Maharashtra's list. Diwali week is the one to calendar deeply: assume reduced capacity, like the Christmas to New Year week at home, except Diwali weeks are longer and more unpredictable. Unused leave is paid out at exit, a statutory settlement item your payroll provider should track without asking. Summer is typically light; monsoon season varies; festival season carries calendar disruption. Plan hiring and project phases around this calendar.

🔒 Data protection shifted to a statutory duty

India's DPDP Act puts statutory obligations on companies handling personal data, and your .NET engineers are inside that perimeter once they touch production. The checklist is straightforward: SSO access with scoped roles, production data pulled only through approved channels, company-managed devices with disk encryption, and exit access revocation. Write a device and security policy into the employment agreement so obligations are enforceable, not aspirational. If customers run vendor audits, formal employment with a registered Indian employer answers sub-processor questions far cleaner than contractor invoices. This is also why the employment structure matters for your legal posture, not just your payroll convenience.

None of this requires a physical office. It requires deciding the rhythm once, documenting it, and holding both sides accountable. The full playbook lives in the no-entity hiring guide, and the core principle is consistency over perfection. Teams that vary the overlap hours, the async norms or the communication style month to month burn out faster than teams that pick a rhythm and keep it.

Every .NET hiring choice flows through one of four models. Here is the honest frame, with where each wins.

The takeaway: contractors work for genuinely independent projects under three months. An entity makes financial sense somewhere past 10 to 15 India employees, and we have documented when that cross happens. Agencies win when you need temporary capacity by Monday. For the team starting with one to fifteen full-time .NET engineers, EOR is the route that is fast, clean on IP and transparent on cost.

One note on us. Versatile runs this on our own registered Bengaluru entity rather than a partner network: your .NET engineers are employed by our entity, PF and TDS filed in house across 28 states, invoices settled at the RBI reference rate with zero FX spread, $149 per engineer per month easing to $129 past twenty heads. Sourcing if you want it, a screened nine-day shortlist at 12 percent of annual CTC, due on day 90. That is the entire commercial model and the full EOR service page has the rest.

⭐ Your structural decision

Hire .NET talent in India for the capability, not for cost savings. Budget the top of the salary band, screen on modern framework depth and code review judgment, plan for the notice period, and structure the employment to withstand an audit. Get those four right and India shifts from experiment to the strongest line in your engineering budget.

🤔 Are India .NET engineers mostly enterprise maintenance people?

A real proportion are, yes. The GCC and services-company population is large and their deep .NET knowledge is sometimes narrow, sometimes deep but in a very specific area like mobile interop or mainframe integration. But the top layer, engineers with shipped ASP.NET Core, cloud architectures and distributed systems thinking, exists in depth in Hyderabad, Chennai, Bengaluru and Pune at 22 to 50 LPA. The filtering is on code, not survey, because the CV is deceptive. An engineer with ten years listed can have shipped either one modern service or none. Technical screens reveal depth in minutes. The rubric from earlier chapters will sort this faster than any conversation.

🤔 Windows versus cross-platform: does the hiring difference matter?

Less than it did. The shift to .NET Core and the prevalence of Kubernetes deployments means almost all new work is Linux-first or platform-neutral. Engineers with deep Windows deployment experience are less common now and less needed. Your screening should focus on cloud and container thinking, not Windows certification or IIS administration. Hyderabad has historically been Windows-heavy due to Microsoft presence; look for people who moved from that to modern Linux deployments, that is a strong signal of someone keeping their skills current. Ask about their last two projects and what platforms they deployed to; the honest answer tells you everything.

🤔 Can I pull .NET engineers out of GCCs?

Yes, but read their scope carefully. A person who spent three years as an SSE building one module inside a large system has shipped less than you think, even with strong technical skills. Someone who ran a project end to end, infrastructure to UI, has shipped more. GCC experience is valuable for discipline, domain knowledge and formal process rigor, but the role boundary in their organization is the interview question: what did they actually own, and what was the wider team responsible for. Ask them to describe a production incident they handled and what they did independently versus what required escalation. That answer will tell you the scope immediately.

🤔 What if my .NET hire does not work out?

Termination in India is straightforward if the paperwork is right. Notice periods run 30 to 60 days as written in the contract, and final settlement covers earned salary, unused leave payout and any gratuity due. Probation clauses, typically three to six months, allow shorter notice early, which is another reason the contract template matters. What you avoid through proper employment is the ugly version: a disputed contractor termination with no paper trail and a disgruntled person with codebase access and incomplete documentation. The formal employment is your protection here too.

🤔 How many .NET engineers until my own entity makes sense?

The breakeven math usually lands between 10 and 15 hires, where entity costs, 30,000 to 50,000 dollars annually in compliance, accounting and payroll overhead, drop below cumulative EOR fees. Below that line, the entity is an expensive bureaucracy. Above it, moving is sensible, and a solid EOR makes the transition simple: contracts reissued on your new entity, PF history preserved, UAN continuity maintained, no missed paychecks in the switch. Run the numbers in the calculator and stress-test it with your actual salary numbers. The calculator is the authoritative answer here.