How to Hire Fintech Software Developers: Skills, Costs, and Hiring Models

Key Takeaways

• When you hire fintech software developers, assess their experience with financial products, transaction workflows, and regulated systems alongside their engineering skills.
• Security and compliance experience should reflect the product scope, with attention to data protection, access controls, transaction security, and audit requirements.
• Choose a hiring model based on product scope, internal capacity, ownership, timeline, and budget. Factor recruitment, management, maintenance, and rework into cost planning.
• Validate production readiness through experience with live financial products, system reliability, financial integrations, incident management, and monitoring.

Why Has Hiring Fintech Software Developers Become a Strategic Engineering Decision?

Banks and financial institutions face a 2026 technology agenda shaped by AI adoption, digital banking modernization, open banking APIs, real-time payments, embedded finance, fraud prevention, compliance pressure, and cloud-native infrastructure. KPMG reports that 80% of surveyed U.S. banking executives expect AI to disrupt their business and operating models within three to five years. The same KPMG research found that 70% of surveyed banking executives planned to implement Real-Time Payments (RTP) and 72% planned to implement FedNow over the following year. Regulatory requirements drive payment modernization for 68% of respondents.

This environment changes what companies need from fintech engineering talent. Financial software handles money, sensitive customer data, regulatory obligations, and services that require dependable access. Programming skills provide limited evidence of a developer's experience with financial workflows, secure system design, compliance controls, and systems built to handle growth.

Companies that hire fintech software developers should assess financial domain knowledge, architecture skills, security experience, compliance knowledge, and experience building systems for increased demand. These capabilities affect product stability, risk exposure, delivery ownership, and development cost.

This guide addresses three questions that shape the hiring decision: Who should you hire? What capabilities should you look for? What will it cost?

Fintech hiring has become an architecture and risk decision alongside a talent decision. Real-time payments, embedded finance, open banking, AI-led financial products, and digital banking modernization increase the number of systems, data flows, and controls within a product. This places greater weight on engineers who can connect product requirements with transaction integrity, security, compliance, scalability, and production ownership.

What Skills Should You Look for When Hiring Fintech Software Developers?

When hiring fintech software developers, companies should assess financial domain expertise, technical architecture, security and compliance, and AI and data capabilities. The evaluation should reflect the product's financial workflows, system integrations, and engineering requirements.

What Fintech Domain Expertise Should Developers Have?

Fintech developers should understand the financial workflows their software supports. The required experience depends on the product category and the risks associated with its operations.

• Payment Gateway and Digital Gateway: Developers should understand gateway integrations, transaction states, failed payments, refunds, reconciliation, and settlement.
• Banking platforms: Candidates should have experience with core banking integrations and the handling of customer and transaction data across banking systems.
• Lending and credit systems: Developers should understand loan applications, credit decisions, repayment workflows, and account servicing.
• KYC and AML: Candidates working on regulated onboarding should understand Know Your Customer (KYC) and Anti-Money Laundering (AML) workflows.
• Trading and wealth management: Developers should have experience with investment transactions and portfolio data.
• Financial operations: Candidates should understand reconciliation, settlement, fraud detection, and financial reporting.

Hiring teams should assess whether candidates understand the consequences of transaction errors, inaccurate financial records, and failures within the workflows they support.

What Technical and Architecture Skills Matter for Fintech Development?

Technical expertise should extend beyond programming languages to the architecture and operation of financial systems.

Backend development experience can include Java, Python, Kotlin, Go, and TypeScript. Candidates should understand API design, databases, data modeling, microservices, and event-driven architecture, where system components communicate through events.

Financial transaction systems require attention to data consistency and failure handling. Developers should understand idempotency, which ensures that repeating an operation has the same intended effect as performing it once. In payment systems, this principle helps prevent duplicate transaction processing. Experience with distributed transactions, message queues such as Kafka, and service failure handling is required for complex financial systems.

Cloud and infrastructure experience can include AWS, Azure, Google Cloud, containers, Kubernetes, and continuous integration and continuous delivery (CI/CD). Knowledge of DevOps, high-availability architecture, and observability, which helps teams track system health and diagnose failures, supports production operations.

What Security, Compliance, and Data Protection Experience Should You Assess?

Security and compliance experience should reflect the financial product's regulatory obligations, architecture, and data protection requirements.

• Regulatory requirements: Developers working on payment systems should understand applicable PCI DSS requirements. Other financial products may involve KYC and AML obligations, privacy requirements, and security controls relevant to SOC 2 examinations.
• Data protection: Candidates should understand encryption, tokenization, which replaces sensitive data with substitute values, and data residency requirements.
• Identity and access management: Developers should know how to control access to financial information based on user roles and permissions.
• Secure API design: Candidates should understand how to protect sensitive information exchanged between applications and financial services.
• Audit trails and data retention: Developers should have experience recording system activities and maintaining records required for audits and compliance reviews.

Hiring teams should assess how candidates apply these controls during system design and development. This includes identifying where sensitive data enters the system, how it moves between services, who can access it, and which records require retention.

What AI, Data, and Automation Skills Matter in Fintech?

AI and data expertise should match the financial use case. Fintech products can use these capabilities for fraud and anomaly detection, risk scoring, intelligent document processing, financial forecasting, reconciliation automation, and AI-powered customer support.

Developers working with machine learning or Retrieval-Augmented Generation (RAG), which uses retrieved information to support AI-generated responses, should understand data pipelines, access controls, model governance, testing, monitoring, and audit records.

The required expertise depends on the product. A payments platform may require stronger transaction architecture skills, while an AI risk product may demand greater experience with data engineering and model governance.

How to Hire Fintech Software Developers: A Step-by-Step Process

Hiring fintech software developers involves defining the product requirements, identifying the right engineering expertise, and assessing whether candidates can handle financial workflows, security obligations, and production responsibilities. The following eight steps provide a process for selecting developers and establishing a fintech engineering engagement.

A fintech project title on a résumé gives limited evidence of engineering ownership. Candidate evaluation should establish the financial workflow involved, the candidate’s responsibilities, the production conditions, and the decisions they owned. Scenario-based assessments can test these capabilities against the requirements of the new product. This approach separates exposure to fintech projects from responsibility for fintech systems.

Step 1: Define Your Fintech Product and Engineering Requirements

Begin by identifying the financial product and the workflows it must support. A payment platform, lending application, digital banking system, insurance product, and wealth management platform have different integration, security, and transaction-processing requirements.

Document the target platforms, financial integrations, expected transaction volumes, scalability requirements, security controls, and applicable compliance obligations. Establish whether the project involves developing a new product, modernizing an existing platform, or connecting legacy financial systems.

This requirements document should establish the technical expertise needed for the project and provide a reference for candidate evaluation.

Step 2: Identify the Required Fintech Development Team

Determine the engineering roles based on the product architecture, delivery scope, and capabilities of the existing team.

A fintech development team may require:

• Backend, frontend, and mobile developers: These engineers build the product's applications, interfaces, and integrations.
• Solution architect: This specialist defines the system architecture and integration approach.
• DevOps or site reliability engineering (SRE) specialists: These engineers manage deployment, infrastructure, and system availability.
• QA automation engineers and security or compliance specialists: These specialists support testing, security controls, and regulatory requirements.
• Data and AI engineers: These engineers support products involving data processing, predictive models, or AI capabilities.

The final team composition should reflect the work required and the responsibilities that existing employees can manage.

Step 3: Choose the Right Hiring Model

The hiring model determines how developers join the project, who manages their work, and how engineering responsibilities are distributed.

Companies can choose in-house hiring, staff augmentation, a dedicated development team, a specialist fintech development partner, project-based fintech development outsourcing, or a hybrid model. Staff augmentation adds external developers to an existing team, while a dedicated team provides a group of engineers assigned to the project. A specialist partner can take responsibility for a defined development scope, and a hybrid model combines internal and external resources.

Compare these options against internal engineering capacity, system criticality, project duration, intellectual property requirements, compliance obligations, and management capacity. The selected model should establish ownership of technical decisions, delivery, and ongoing support.

Step 4: Find and Shortlist Fintech Developers

Search for candidates and development partners with experience that matches the financial product and its engineering requirements.

Review portfolios and project histories for comparable work involving payments, banking, lending, insurance, or investment platforms. Examine the technologies used, financial integrations delivered, transaction volumes supported, and security or compliance responsibilities handled.

Geographic location and time-zone overlap should form part of the shortlist criteria when the project requires shared working hours or coordination between internal and external teams.

Step 5: Evaluate Technical and Fintech Domain Expertise

Use technical assessments based on financial-system problems that candidates may encounter during development.

For example, a payments engineering assessment can ask candidates to design an API that prevents duplicate transactions when a customer repeats a payment request. A banking integration exercise can examine how they handle inconsistent records or service failures.

The evaluation should cover four areas:

• Financial workflows: Assess knowledge of the transactions, business rules, and integrations relevant to the product.
• Technical architecture: Test API design, data consistency, scalability, and failure handling.
• Security and compliance: Examine how candidates protect sensitive financial information and apply relevant controls.
• System reliability: Assess decisions involving service interruptions, transaction recovery, and increased processing demand.

These exercises provide evidence of how candidates apply engineering knowledge to financial-system requirements.

Step 6: Validate Production Experience

Request evidence of financial software that candidates have helped deploy and support in production. A project portfolio should establish the work performed and the responsibilities held by the candidate or team.

Examine transaction volumes, uptime commitments, service-level agreements (SLAs), legacy-system integrations, cloud architecture, and performance requirements. Ask how the team handled incidents, monitored system health, and diagnosed failures through observability tools.

Confirm which architecture decisions, deployments, incident responses, and performance improvements the candidate owned. This helps distinguish experience contributing to a project from responsibility for its production operation.

Step 7: Review Costs, Contracts, and Ownership

Compare hiring options using total cost of ownership, including developer rates and the additional expenses associated with each engagement. The assessment should include development, recruitment or onboarding where applicable, management, infrastructure, security, compliance, maintenance, and potential rework.

Before signing the contract, establish the following terms:

• Intellectual property: Define ownership of source code, documentation, and project deliverables.
• Confidentiality and data access: Document nondisclosure obligations, access permissions, and responsibilities for sensitive financial information.
• Delivery and support: Agree on SLAs, maintenance commitments, and responsibilities during production incidents.
• Handover: Define documentation requirements, knowledge transfer, and the process for transferring engineering responsibilities.

These terms establish financial commitments and clarify responsibilities during development and after the engagement.

Step 8: Start With a Controlled Engagement

For projects involving regulated data, critical transaction flows, complex integrations, or legacy systems, begin with a defined engagement before expanding the development team.

The initial scope can involve discovery, an architecture assessment, a technical pilot, a minimum viable product (MVP), or a development module. Select work that can demonstrate the team's ability to meet the product's engineering requirements.

Establish acceptance criteria for functionality, code quality, security, documentation, and ownership before development begins. Review the completed work against these criteria, including how the team handles technical issues and communicates engineering decisions.

Expand the engagement after the initial work meets the agreed acceptance criteria.

How Should You Evaluate Fintech Developers Before Hiring?

Before companies hire fintech developers, the evaluation should verify experience with financial products, production systems, security controls, and transaction workflows. Portfolio evidence, fintech-specific assessments, and scenario-based interviews can reveal whether that experience matches the project.

What Should You Verify in a Fintech Developer’s Portfolio?

Review projects with financial workflows and operating conditions that resemble your product. Check the product type, transaction volumes, production scale, regulatory environment, third-party financial integrations, and security or compliance responsibilities.

Ask candidates to identify their role, decisions, and deliverables within each project. Request evidence that supports claims about architecture, integrations, production operations, or security ownership. This helps distinguish team participation from individual responsibility.

What Technical Assessments Should You Use for Fintech Developers?

Build assessments around financial-system scenarios. Test payment failure and retry handling, idempotency, API security, transaction consistency, fraud detection architecture, data encryption, audit logging, and distributed-system failures.

Idempotency prevents repeated requests from creating duplicate transactions. Code-review exercises can test error handling, data integrity, security controls, and maintainability. System-design exercises can test transaction flows, failure handling, service dependencies, and data protection.

What Scenario-Based Questions Should You Ask Fintech Developers?

Use questions that require candidates to explain engineering choices within financial workflows:

• How would you design a payment API that prevents duplicate transactions?
• How would you handle a failed transaction after funds have been debited?
• How would you connect a legacy banking system to a modern API layer?
• How would you create an audit trail for financial transactions?
• How would you protect sensitive financial data during storage and transfer?

Assess each response against transaction integrity, failure recovery, security controls, auditability, and system dependencies. Ask candidates to explain the trade-offs behind their design choices and the evidence they would use to validate the proposed solution.

What Roles Should a Fintech Development Team Include?

A fintech development team should match the product scope, engineering objective, and ownership requirements. Companies that hire fintech software developers should define roles based on the work each specialist will own.

Which Roles Can a Fintech Development Team Require?

A typical team can include:

• Solution or Software Architect: Defines system structure, service boundaries, integrations, and dependencies.
• Backend Engineers: Build APIs, transaction services, business logic, and financial integrations.
• Frontend or Mobile Engineers: Build web and mobile product interfaces.
• DevOps or Site Reliability Engineering (SRE) Specialists: Manage infrastructure, deployments, availability, and monitoring.
• QA and Automation Engineers: Test financial workflows, integrations, failures, and releases.
• Data and AI Engineers: Build data pipelines, analytics, risk models, and AI features.
• Security Engineer: Defines application, infrastructure, access, and data security controls.
• Business or Domain Analyst: Connects financial workflows and regulatory requirements with product requirements.
• Product or Project Manager: Manages scope, priorities, dependencies, delivery, and stakeholder coordination.

What Determines the Fintech Team Composition?

The engineering objective determines the role mix. Building can require a complete product team. Modernizing can require architecture, backend, DevOps, and migration skills. Integrating can require backend and architecture expertise. Scaling can require SRE, QA automation, and performance engineering. Maintaining can require engineering, security, testing, and support roles.

Which Fintech Developer Hiring Model Fits Your Project?

Choosing a fintech developer hiring model requires companies to assess internal engineering capacity, system criticality, intellectual property requirements, delivery timelines, compliance obligations, and long-term ownership. The decision should establish who manages development, controls sensitive data, makes architecture decisions, and supports the product after release.

What Should Determine Your Fintech Hiring Model?

1. In-House Development Team

An in-house team suits companies building core financial platforms that require internal control over architecture, sensitive data, intellectual property, and product knowledge. This model supports long-term engineering ownership but involves recruitment costs, employee expenses, and responsibility for managing the team.

2. Staff Augmentation

Staff augmentation allows companies to hire external developers to fill skill gaps within an existing engineering team. It suits projects that require additional backend, mobile, cloud, or security expertise without transferring project management to an external provider.

The internal team retains responsibility for architecture, task allocation, compliance, and delivery.

3. Dedicated Development Team

A dedicated development team provides engineers assigned to a fintech product for an extended engagement. This model suits companies that need sustained development capacity for a new platform, product expansion, or modernization program.

The agreement should define who manages development, makes technical decisions, controls data access, and handles documentation and knowledge transfer.

4. Specialist Fintech Development Partner

A specialist fintech development partner suits projects involving complex financial workflows, regulated platforms, legacy modernization, or integrations with banking and payment systems. Companies can engage such partners when the project requires expertise across architecture, development, security, testing, and financial integrations.

Clutch can help companies shortlist fintech development partners through verified client reviews, service listings, and industry-specific portfolios. Companies can use its financial app development directory to compare providers, review client feedback, and assess experience with financial products. The final selection should depend on evidence of relevant fintech projects, technical capabilities, security practices, and production experience.

Companies should examine production experience, financial integration capabilities, security practices, and client references. Technical assessments should establish whether the partner can handle transaction failures, data consistency, compliance requirements, and system reliability.

5. Project-Based Fintech Development Outsourcing

Project-based fintech development outsourcing allows companies to assign a defined software development project or component to an external provider. The provider manages delivery of the agreed scope, which may involve building a financial application, modernizing a platform component, or developing integrations with banking and payment systems.

This arrangement differs from staff augmentation because the provider takes responsibility for managing the contracted development work. Companies should define project scope, delivery milestones, acceptance criteria, intellectual property ownership, security obligations, data-access permissions, and support requirements in the agreement.

Project-based outsourcing can involve a specialist fintech partner. The distinction concerns the delivery arrangement and the responsibilities assigned to the provider.

6. Hybrid Development Model

A hybrid model combines internal engineering teams with external developers or development partners. It suits companies that want to retain control over critical architecture, sensitive financial data, intellectual property, and compliance decisions while using external teams for development or specialist engineering work.

Responsibilities for system integrations, testing, deployment, and production support should be defined across both teams to prevent gaps in delivery ownership.

How Do Fintech Developer Hiring Models Compare?

The hiring decision should reflect the company's ability to manage engineering work, the sensitivity of its financial systems, compliance requirements, and the level of ownership it intends to retain. Dedicated teams, specialist partnerships, and project-based outsourcing can overlap. The contract should establish the delivery arrangement, management responsibilities, and engineering ownership for the selected engagement.

How Much Does It Cost to Hire Fintech Software Developers?

The cost of hiring fintech software developers depends on the required expertise, product architecture, financial integrations, security controls, and delivery responsibilities. Companies should assess developer rates alongside the expenses involved in building, releasing, and maintaining the product.

Two fintech teams with similar hourly rates can create different cost structures because their responsibilities differ. A team responsible for transaction architecture, security controls, financial integrations, testing, documentation, and production support carries a different scope from a team assigned feature development. Comparing total cost of ownership against defined responsibilities gives product leaders a stronger basis for evaluating hiring models.

What Factors Affect the Cost of Hiring Fintech Developers?

The cost of hiring fintech developers depends on the following factors:

• Location: Regional labor markets, operating costs, and hiring conditions influence developer rates.
• Experience and seniority: Senior engineers and architects command different rates from junior developers because their work involves system design, technical decisions, and production responsibilities.
• Fintech specialization: Projects involving payment processing, digital lending, core banking, fraud detection, or financial reporting may require engineers with relevant domain experience.
• Architecture complexity: High transaction volumes, distributed systems, legacy platforms, and performance requirements influence the engineering skills and effort needed.
• Security requirements: Encryption, access controls, security testing, and protection of sensitive financial information contribute to development costs.
• Compliance obligations: Regulatory requirements can create additional work involving audit trails, documentation, testing, and control implementation.
• Financial integrations: Connecting banking APIs, payment gateways, identity verification services, and external financial systems requires development and integration testing.
• Team size and composition: The cost depends on the number of developers and the need for architects, QA engineers, security specialists, and DevOps engineers.
• Project duration: Longer engagements involve sustained staffing, project management, infrastructure, and support commitments.
• Maintenance requirements: Production monitoring, incident response, security updates, defect resolution, and system improvements create costs beyond the initial release.

These factors help companies define the engineering scope and estimate the resources required before requesting proposals.

What Are Fintech Developer Hourly Rates by Region?

Regional software outsourcing rates provide a reference for estimating development costs. The following table presents published 2026 hourly benchmarks for senior software developers working through outsourcing providers. The figures represent general software development services, not fintech-specific rates.

These rates are indicative software development outsourcing benchmarks, not fixed fintech developer rates. Fintech expertise, seniority, security requirements, architecture responsibilities, and engagement models can affect the final cost. Companies should compare quotations based on equivalent roles, project scope, and delivery responsibilities.

What Should You Include in the Total Cost of Ownership?

Total cost of ownership (TCO) covers the expenses involved in hiring developers, delivering the product, and maintaining the system. A fintech development budget should account for three cost categories.

1. Hiring and Team Management Costs

In-house hiring involves recruitment, compensation, onboarding, training, and employee management. External engagements involve provider fees, team coordination, contract management, and knowledge transfer.

The hiring model determines which costs the company manages and which expenses form part of the provider's contract.

2. Product Development and Release Costs

Development expenses cover architecture, application development, financial integrations, quality assurance, security controls, compliance-related engineering, and deployment infrastructure.

A proposal covering application development may exclude architecture reviews, security testing, or integration validation. Companies should identify these exclusions before comparing costs.

3. Production Support and Maintenance Costs

A fintech product requires resources for hosting, monitoring, incident response, defect resolution, security updates, and maintenance. The estimate should account for engineering responsibilities that continue after release.

Companies should include a budget allowance for changes and rework based on integration complexity, technical risks, and expected requirements.

Consider two proposals for developing a payment application. Both quote the same developer rate, but one includes transaction architecture, integration testing, security reviews, deployment, and production support. The other covers application development and requires the company to arrange the remaining work.

The second proposal may have a lower initial contract value while creating additional expenses for internal engineers or external specialists. Comparing the complete scope, excluded services, and expected support costs gives product leaders a basis for assessing the financial impact of each hiring model.

What Mistakes Should You Avoid When Hiring Fintech Developers?

Companies that hire fintech developers should watch for hiring decisions that create gaps in domain knowledge, security, production readiness, cost control, or system ownership.

1. Are you hiring based on programming languages and frameworks?
   Evaluate experience with financial workflows and transaction systems alongside technical skills.
2. Are you treating fintech domain knowledge as optional?
   Require experience relevant to the product, such as payments, lending, banking integrations, reconciliation, or financial data.
3. Are you relying on generic coding assessments?
   Use fintech-specific scenarios that test transaction failures, API security, data integrity, financial integrations, and audit requirements.
4. Are you overlooking security, compliance, and production-scale experience?
   Verify experience with security controls, regulatory requirements, production incidents, system reliability, and financial workloads at the expected scale.
5. Are you choosing the lowest hourly rate?
   Compare total cost of ownership, including management, security, compliance, maintenance, and rework costs.
6. Are ownership boundaries unclear?
   Define intellectual property ownership, data access, architecture ownership, engineering standards, and system ownership. For multi-vendor projects, assign ownership for shared architecture and cross-system decisions to prevent responsibility gaps.

What Should Be on Your Fintech Developer Hiring Checklist?

Use this checklist to verify requirements, candidate capabilities, and engagement terms at each stage of the hiring process.

What Should You Define Before Hiring?

• Have you documented the business and technical requirements?
• Have you identified the required fintech domain expertise?
• Have you mapped the regulatory and compliance requirements?
• Have you assigned architecture responsibilities?
• Have you established the budget and delivery timeline?

What Should You Check During Developer Evaluation?

• Have you reviewed projects with relevant financial workflows?
• Have you tested system-design skills using fintech scenarios?
• Have you assessed security and compliance knowledge?
• Have you validated financial API and integration experience?
• Have you conducted scenario-based technical interviews?

What Should You Confirm Before the Engagement Starts?

• Does the nondisclosure agreement (NDA) define confidentiality requirements?
• Does the contract define intellectual property ownership?
• Are data-access controls and security requirements documented?
• Are service-level agreement (SLA) and quality expectations defined?
• Are documentation and knowledge-transfer responsibilities assigned?
• Are support and maintenance responsibilities defined?

Why Should You Choose GeekyAnts for Fintech Software Development?

GeekyAnts combines fintech product development with AI-powered digital product engineering. Our experience spans digital banking, payments and wallets, lending and mortgages, wealth management, financial integrations, and platform modernization.

Our teams work across mobile and web applications, backend systems, cloud engineering, financial integrations, QA, security, and AI engineering. This scope supports fintech products from architecture and application development through deployment, modernization, maintenance, and post-launch optimization.

Our portfolio includes a global payment platform processing 400+ million payments per year. Our BFSI experience covers platforms handling 50+ million transactions per day and banking ecosystems serving 5+ million active users. The work spans core banking modernization, payment infrastructure, lending products, investment platforms, regulatory migrations, and financial applications.

This experience gives fintech teams access to engineering capabilities across customer applications, transaction systems, integrations, cloud infrastructure, security controls, and product modernization within one engagement.

Fintech partner selection involves a broader assessment than developer capacity or rate. Buyers need to examine the responsibilities covered by the engagement, including architecture, application engineering, financial integrations, cloud infrastructure, quality assurance, security, modernization, and post-launch support. Clear ownership across these areas reduces responsibility gaps and gives the client a defined operating model for product delivery.

Conclusion

Hiring fintech software developers requires matching engineering expertise with the financial workflows, security requirements, and production responsibilities of the product. Companies should assess candidates through relevant project evidence, fintech-specific technical evaluations, and defined ownership requirements. The selected hiring model should support the product's development needs, compliance obligations, and long-term maintenance without creating gaps in engineering accountability.

Sources and Citations

1. https://kpmg.com/us/en/articles/2026/kpmg-banking-technology-survey.html
2. https://www.fincen.gov/resources/statutes-and-regulations/cdd-final-rule
3. https://www.pcisecuritystandards.org/standards/pci-dss/
4. https://www.aicpa-cima.com/topic/audit-assurance/audit-and-assurance-greater-than-soc-2
5. https://pangea.ai/resources/complete-guide-to-software-project-outsourcing-2025
6. https://www.federalreserve.gov/frrs/guidance/interagency-guidance-on-third-party-relationships.htm