Salesforce · Jungo Customization

Most "customization" requests are configuration nobody finished.

Custom code has a maintenance tail forever, so the first useful question is whether you need any. We classify every request as configuration, development, or already-possible-and-unbuilt — then build only what genuinely needs building, beside the managed package, through a sandbox, documented. We draw the line before we quote, not in a change order.

Classification Model
WHAT WE EXTEND The Managed Package Extended beside, never edited The Salesforce Platform Objects · Flow · Apex · LWC Request backlog LOS field map Existing automation TWOPIR CLASSIFICATION LAYER Configure Picklists · Layouts Flow · Report types Develop Apex · LWC Callouts · Batch Govern Sandbox · Release Regression · Change log CLASSIFY FIRST · BUILD ONLY WHAT MUST BE BUILT 2πr WHAT YOU GET Cheapest Level Solved with config wherever it can be A Protected Sync Regression pass before every release A Changeable Org Documented, versioned, safe to modify CLASSIFY · DESIGN · BUILD · RELEASE
3
Ways every request is classified
0
Changes released without a sandbox pass
40+
Certified delivery team
12+
Years building revenue systems

Trusted by 500+ organizations — including mortgage lenders, brokerages and loan-officer teams running their pipeline on Salesforce with Twopir Consulting.

Zapier
SMS-Magic
FormAssembly
Conga
Celigo
PandaDoc

Built for Mortgage Operations

  • Salesforce Partner
  • HubSpot Partner
  • Jungo — The Mortgage App
  • Encompass LOS Sync
  • Calyx Point · Byte · LendingPad
  • Floify · DocsBar
  • Optimal Blue · Mortgage Coach
  • Salesforce Flow Automation
Where It Goes Wrong

Six ways custom work makes an org harder to change

Customization is supposed to make a system fit better. Done without classification and governance it does the opposite. Every change gets slower.

Everything gets called a customization

A missing picklist value and a multi-object Apex routine arrive in the same request queue at the same priority. One is an afternoon, the other is a project, and nobody separates them.

Flows accumulate on the same object

Three admins over two years, no documentation, no change control. Each new automation takes longer to build than the last because nobody can safely predict what it will collide with.

Picklists drift from the origination system

Milestone and stage values are customer-editable. Once they diverge from the field map, alerts fire on the wrong values and the pipeline report quietly stops matching the loan file.

Custom work has no release path

Built in production, tested in production, discovered in production. The first regression takes the milestone alerts down during a closing week.

Nobody knows what is already there

Requests get built twice because the existing automation is undocumented. The org grows heavier without getting more capable.

Custom work replaces cheaper configuration

Real development quoted for something the admin tools already do. It works, it bills well, and you maintain it forever for no reason.

Configuration vs Development

The boundary almost no partner page will actually draw

It decides your price, your timeline and your maintenance burden — so it belongs at the top of the conversation, not in a change order.

Configuration is everything reachable through Salesforce admin tools. Picklist values, record types, page layouts, validation rules, report types, permission sets and Flow. In Jungo — The Mortgage App this covers more ground than most teams assume, because the product deliberately reuses the standard platform — Contact, Task, Event, Case, Flow and the report builder are stock, and the vendor documents editing fields on Contact, Loan and Task through a single help article.

Development begins where those tools cannot express the requirement. Logic Flow cannot model or cannot scale to, bulk processing past declarative limits, callouts to a system with no maintained connector, an interface Lightning pages cannot produce. This is Apex and Lightning Web Components, and it lives beside the managed package rather than inside it — you cannot edit package internals, so extensions reference the product rather than modify it.

There is a third category worth naming, because it is the most common one: already possible and simply unbuilt. A picklist nobody extended, a recipient matrix nobody finished, a report type nobody created. We work with growing, mid-market, and enterprise organizations that need help with complex CRM implementations, integrations, and business system challenges, and classifying the request honestly is the first thing we do.

How We Classify

Where a request lands, and what that costs you

Real examples from lending orgs, sorted the way we sort them on the first call.

RequestClassificationWhyMaintenance it creates
Add a loan stage the origination system already usesConfigurationPicklist values are customer-editable by design.Keep it reconciled with the field map.
Send the listing agent a different milestone setAlready possible, unbuiltThe recipient matrix is configuration on every rollout.None beyond the Flow itself.
Escalate a file stalled more than five daysConfigurationA scheduled Flow with an SLA clock covers it.One Flow, documented and versioned.
Roll partner profitability over three years of funded volumeConfigurationCustom report type plus roll-up or formula fields.Metric definitions must stay documented.
Recalculate pricing across 40,000 contacts nightlyDevelopmentVolume exceeds what declarative tools handle reliably.Apex with test coverage and a deployment path.
Push data to a lender system with no connectorDevelopmentNeeds an authenticated callout and error handling.Integration code, monitoring and retry logic.
Give partners a self-service view the portal does not shipDevelopmentExperience Cloud work past shipped behaviour.Portal components plus a compliance review.
Roughly two-thirds of the requests we are asked to quote as development turn out to be one of the first two rows. We check that before we price anything.
What We Build

Six areas where we extend a Jungo org safely

Everything here is built beside the managed package, released through a sandbox, and documented so the next person can change it.

Objects, Fields & Record Types

The data model extended to carry what your firm actually tracks, without touching the managed package internals.

  • Custom fields on Contact, Loan and Task
  • New custom objects alongside the package where warranted
  • Record types and page layouts by role and practice
  • Validation rules that enforce the process at entry
  • Field-level security and record-visibility design

Flow Automation

Automation past the shipped templates — built to a standard, documented, and released through a sandbox rather than straight into production.

  • Record-triggered and scheduled Flows
  • Milestone logic beyond the ten shipped templates
  • Routing, escalation and SLA-clock automation
  • Consolidating contending Flows on the same object
  • Change control, versioning and a documented release path

Apex & Lightning Components

Real development, where the admin tools genuinely run out — quoted separately and only when the requirement justifies the maintenance.

  • Apex for logic Flow cannot express or cannot scale to
  • Bulk and batch processing beyond declarative limits
  • Lightning Web Components for purpose-built interfaces
  • API callouts to systems with no maintained connector
  • Test coverage and deployment through a managed pipeline

Agent Portal Extensions

The referral-partner experience pushed past its shipped behaviour — carefully, because some of its controls touch compliance.

  • Experience Cloud layout and branding work
  • Additional partner-facing data and self-service actions
  • Pre-approval ceiling review with your compliance team
  • Partner permission and record-visibility design
  • Portal engagement reporting back into the CRM

Custom Reporting & Analytics

Report types and dashboards that answer the questions your leadership actually asks, rather than the ones the shipped reports happen to cover.

  • Custom report types across contacts, loans and referrals
  • Pull-through, cycle-time and partner-profitability models
  • Formula and roll-up fields that carry the metric definitions
  • Dashboards by role: principal, branch manager, loan officer
  • Definitions documented so two reports cannot disagree

Governance & Technical Debt

The work that makes every later change cheaper — usually the highest-return engagement in an org that has been live a few years.

  • Automation inventory and contention analysis
  • Picklist reconciliation against the origination field map
  • Sandbox strategy and deployment process
  • Regression checks on sync and milestone Flows
  • Architecture documentation and a change log
How We Deliver

Five steps, starting with the cheapest question

Classify first. It is the step that most often removes the project entirely, which is exactly why it goes first.

Step 01

Classify the Request

Configuration, development, or already-possible-and-unbuilt. This is the cheapest step and it changes the price of everything after it.

Step 02

Check What Exists

Automation inventory on the affected objects, so we extend rather than collide — and so nothing gets built twice.

Step 03

Design & Quote

The approach, the maintenance it creates, and a separate price for anything that crosses into real development.

Step 04

Build in a Sandbox

Built and tested away from production, including a regression pass over the origination sync and the milestone Flows.

Step 05

Release & Document

Deployed through a managed path, with architecture notes and a change-log entry, so whoever inherits it can change it safely.

Client Outcomes

What well-scoped custom work actually moves

Two engagements where the value came from building the right thing, at the right level of the stack, and not building the rest.

★★★★★
The enrichment and scoring work changed which leads our reps saw first. They identified high-value leads about 30% faster, and lead-scoring accuracy improved around 25% once the rules were built on real engagement and firmographic signals rather than guesswork.
Revenue Operations Lead Mid-market FinTech · 250 employees · North America Lead Scoring
Case Study

Mid-Market FinTech — 250 Employees

Salesforce CPQ with Apollo.io enrichment, Outreach sequences and Zapier workflow automation across one connected sales stack.

30% Faster high-value lead identification
25% Improvement in lead-scoring accuracy
1 Connected stack, not four disconnected tools
Read Integration Story
★★★★★
Twopir rebuilt how leads reach an agent and how a deal becomes a signed contract. Contract turnaround dropped from two or three days to under four hours, and the error rate on documents went to near-zero because the data was coming straight out of the CRM instead of being re-keyed.
Operations Director Luxury real estate conglomerate · 250+ agents Lead-to-Contract
Case Study

Real Estate Group — 250+ Agents

Sales operations and lead management rebuilt on Salesforce, from lead routing through to contract generation and commissions.

4 hrs Contract turnaround, from 2–3 days
~0 Document error rate after CRM-sourced data
250+ Agents on one routing model
Read Full Case Study
Why Twopir

The cheapest customization is the one you do not need

We are a Salesforce Partner with an Apex and Lightning practice. That is exactly why we are comfortable telling you a request is a picklist.

We classify before we quote

Configuration, development or already-possible. Most requests land in the third category, which is the cheapest possible answer and the one a development-only shop has no incentive to find.

We will not build what the admin tools already do

Custom code has a maintenance tail forever. If a picklist value, a report type or a Flow solves it, that is what we build — and we say so even when the code would bill better.

We protect the sync and the alerts

Picklist drift against the origination field map is the quietest failure in this product. Every change set gets a regression pass over the sync and the milestone Flows before release.

We consolidate rather than accumulate

Contending Flows on one object is the commonest technical debt we find. Fixing it makes every future request cheaper, which is why we price it as an investment rather than a clean-up.

We document as a deliverable, not a favour

Architecture notes, a change log and a release path. The measure of good custom work is whether the next person can safely modify it without calling us.

Common Questions

Answers before the first call

Configuration is anything reachable through Salesforce admin tools: picklist values, record types, page layouts, validation rules, report types, permission sets and Flow. That covers most of what lenders ask for. Development begins where those tools cannot express the requirement — complex multi-object logic, callouts to a system with no connector, bulk processing beyond Flow limits, or an interface Lightning pages cannot produce. We name which side a request falls on before quoting it, because the two have very different costs and very different maintenance.

Custom fields on Contact, Loan and Task are ordinary configuration, and the vendor documents editing them through a single help article — a fair signal those three are the core records. New custom objects alongside the package are also fine. What you cannot do is alter the internals of a managed package, so extensions live beside it and reference it rather than editing it.

Well-built extensions should not, because they sit beside the package rather than inside it. The real risk is elsewhere: picklist values are customer-editable and drift against the origination system field map, and Flows built by different people over years start contending on the same object. We manage that with change control, a sandbox release path and a regression check on the sync and the milestone Flows before anything reaches production.

Often, and it is worth scoping carefully. The portal lets referral partners see status, leave notes, submit referrals and reissue pre-approval letters up to a ceiling the loan officer sets. That editable ceiling is a control worth reviewing with your compliance team before you widen it. Extensions beyond the shipped behaviour are Experience Cloud work and are quoted as development, not configuration.

Less than most teams expect. In our experience the majority of "we need a customization" requests are unbuilt configuration — a picklist nobody extended, a recipient matrix nobody finished, a report type nobody created. We check that first, because it is faster and cheaper and there is nothing to maintain afterwards.

Always, and it is not optional at our end. An org where three people built Flows on the same object over two years, undocumented, is the single most common thing we are called in to untangle. You get architecture documentation, a change log and a release path, so the next person to touch it is not doing archaeology.

Yes, and that is a common arrangement. Automation here is Salesforce Flow, so anything can be built and somebody has to own it afterwards. Where that owner does not exist internally we provide the capacity on a retained basis; the support page covers how that works.

Next Step

Send us the request list, and we will tell you what is actually custom

Classification is an hour of work and routinely removes most of a backlog. What is left gets designed properly, built in a sandbox, and documented for whoever owns it next.

Related: Jungo & Salesforce overview · Salesforce for mortgage lending · All Jungo services · Jungo implementation

Built beside the package · released through a sandbox · documented as a deliverable