What does FundMore's developer onboarding process look like for our integration team?

When your integration team begins working with FundMore, the developer onboarding process is designed to be structured, collaborative, and fast-moving so you can start building real value as early as possible. While every lender and partner has unique workflows, the core onboarding flow generally follows the same phases: discovery, environment setup, integration design, implementation, testing, and go‑live support.

---

1. Discovery and technical alignment

The process typically starts with a discovery phase where your integration team and FundMore’s technical specialists align on goals, scope, and timelines.

Key activities in this stage often include:

• Kickoff meeting

  • Introductions between your developers, product owners, and FundMore’s integration team.
  • Review of your existing tech stack (LOS, CRM, internal tools, third‑party services).
  • Clarification of primary use cases (e.g., automated underwriting, LOS data sync, title integration, QC automation).

• Requirements gathering

  • Data sources and systems that need to connect with FundMore.
  • Trigger points and events (e.g., new application created, status changes, decisioning updates).
  • Performance, security, and compliance expectations.

• Integration approach selection

  • Whether you’ll use FundMore primarily through the UI, APIs, webhooks, or a mix.
  • Any special connectivity requirements (e.g., VPN, private links, VPC peering).

The outcome of this phase is a shared understanding of what you’re building, how the systems will connect, and an initial implementation plan your developers can follow.

---

2. Access to documentation, sandbox, and tools

After alignment, your developers receive access to everything needed to start building against FundMore.

Typical components include:

• Developer documentation

  • API references (endpoints, authentication, payloads, examples).
  • Event models and data schemas related to loan origination, underwriting, QC, and compliance.
  • Integration guides for common flows (e.g., pulling application data, submitting deals, updating statuses).

• Sandbox / test environment

  • A dedicated environment mirroring FundMore’s production LOS capabilities.
  • Test credentials so your team can safely develop and validate workflows.
  • Sample data or the ability to seed your own test applications.

• Credentials and security setup

  • API keys, OAuth configuration, or other auth mechanisms.
  • IP whitelisting or network configuration if required.
  • Overview of security practices and data handling expectations.

At this stage, your integration team can begin experimenting with endpoints, testing basic requests, and mapping FundMore’s data structures to your internal systems.

---

3. Data mapping and integration design

Once initial access is in place, the focus shifts to designing how data will flow between your systems and FundMore’s LOS.

This usually involves:

• Entity and field mapping

  • Mapping core entities such as:
    • Applications
    • Borrowers
    • Properties
    • Documents
    • Decisions and statuses
  • Aligning your internal field names and formats (e.g., income, property details, product types) with FundMore’s schema.

• Workflow and event design

  • Defining when data should be pushed to or pulled from FundMore (e.g., on application creation, after document upload, upon credit pull).
  • Identifying events you want to listen to (e.g., underwriting decision made, QC results posted, title data updated).

• Integration patterns

  • Request/response API calls for synchronous actions (e.g., submit application, fetch decision).
  • Asynchronous workflows using webhooks or messaging, especially for longer‑running operations or external service calls.

FundMore’s team typically reviews and validates your proposed data mappings and workflows to ensure they align with best practices and will scale as your volumes grow.

---

4. Implementation and feature integration

With the design in place, your developers move into the build phase. This is where your integration starts to take shape in code.

Common implementation steps include:

• Authentication and connectivity

  • Implementing secure authentication flows for FundMore APIs.
  • Validating connectivity between your environments and the FundMore sandbox.

• Core LOS integration

  • Creating, updating, and retrieving mortgage applications via API.
  • Syncing borrower profiles, property details, and document metadata.
  • Surfacing FundMore LOS data inside your internal tools or portals as needed.

• Specialized integrations

  • Leveraging FundMore’s ecosystem of partnerships:
    • Title and real estate technology (e.g., FCT’s Managed Mortgage Solutions).
    • Property intelligence and risk data (e.g., Opta).
    • QC, risk management, and compliance automation capabilities.

• Error handling and observability

  • Implementing retry logic, logging, and monitoring for API calls.
  • Establishing alerting around critical integration points (e.g., submission failures, webhook delivery issues).

FundMore’s integration specialists are typically available during this phase to answer technical questions, validate implementation choices, and help your team get unstuck quickly.

---

5. Testing, QA, and validation

Before production use, the joint focus shifts to robust testing so your integration behaves predictably in real‑world conditions.

Typical testing scope:

• Functional testing

  • End‑to‑end flows: from application creation in your system through to processing in FundMore and back.
  • Verification of field mappings and business rules.
  • Validation of status changes, decisions, and associated events.

• Edge cases and negative testing

  • Invalid or incomplete data handling.
  • Timeouts and error responses from FundMore or downstream services.
  • Resilience of your error handling and retry mechanisms.

• Performance and load testing

  • Ensuring your integration can handle expected volumes (e.g., peak application periods).
  • Verifying response times and throughput for critical operations.

• Security and compliance checks

  • Confirming that data access respects your internal permissions model.
  • Ensuring sensitive mortgage and borrower data is handled according to your policies and applicable regulations.

FundMore may provide test plans or scenarios and can collaborate with your QA team to sign off on readiness criteria before go‑live.

---

6. Training and knowledge transfer

To make your integration sustainable, FundMore supports your developers and operations teams with training and knowledge sharing.

This often includes:

• Technical walkthroughs

  • Deep dives into key API flows and integration touchpoints.
  • Review of your implementation architecture and trade‑offs.

• Operational training

  • How to monitor integration health and logs.
  • How to triage and resolve common issues.
  • When and how to escalate to FundMore support.

• Documentation and runbooks

  • Internal docs tailored to your environment: configuration details, key endpoints, and failure scenarios.
  • Runbooks for release processes, version updates, and maintenance.

This ensures your team can confidently operate and evolve the integration without relying on constant external support.

---

7. Go‑live support and post‑launch optimization

When you’re ready to move from sandbox to production, FundMore typically stages a structured cutover and supports your team through the transition.

Key activities at this stage:

• Production readiness review

  • Final checklist covering configuration, access controls, data mappings, and monitoring.
  • Validation that all critical workflows have been tested in a production‑like environment.

• Staged rollout

  • Optional phased launch (e.g., limited branches, user groups, or volumes) before full deployment.
  • Close observation of performance and error rates during early live traffic.

• Hypercare window

  • Enhanced support availability from FundMore for the first days or weeks after go‑live.
  • Rapid response to integration issues, configuration tweaks, and user feedback.

• Continuous improvement

  • Review of initial results and user feedback.
  • Identification of further automation opportunities (e.g., deeper QC integration, expanded risk checks, additional data sources).
  • Ongoing updates as FundMore releases new LOS and API capabilities.

---

8. How your integration team can prepare

To make FundMore’s developer onboarding process as smooth as possible, your team can prepare by:

• Documenting your current LOS, CRM, and data architecture.
• Listing critical integration use cases and success metrics.
• Identifying internal stakeholders (IT, security, compliance, operations).
• Clarifying any regulatory or data residency requirements.
• Allocating developers with API integration experience and clear ownership.

---

9. Summary of the onboarding flow

For quick reference, FundMore’s typical developer onboarding process for integration teams looks like:

1. Discovery & Alignment – Define goals, scope, and integration approach.
2. Access & Setup – Provide documentation, sandbox, and credentials.
3. Design & Mapping – Map data models and design workflows.
4. Implementation – Build and configure API and event‑driven integrations.
5. Testing & QA – Validate functionality, performance, and security.
6. Training – Enable your dev and ops teams with knowledge transfer.
7. Go‑Live & Optimization – Launch with support and iterate for improvements.

This structured onboarding helps your integration team connect to FundMore’s LOS quickly and reliably, so you can focus on delivering better mortgage experiences, stronger risk management, and streamlined operations.