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.
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.
Trusted by 500+ organizations — including mortgage lenders, brokerages and loan-officer teams running their pipeline on Salesforce with Twopir Consulting.












Built for Mortgage Operations
Customization is supposed to make a system fit better. Done without classification and governance it does the opposite. Every change gets slower.
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.
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.
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.
Built in production, tested in production, discovered in production. The first regression takes the milestone alerts down during a closing week.
Requests get built twice because the existing automation is undocumented. The org grows heavier without getting more capable.
Real development quoted for something the admin tools already do. It works, it bills well, and you maintain it forever for no reason.
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.
Real examples from lending orgs, sorted the way we sort them on the first call.
| Request | Classification | Why | Maintenance it creates |
|---|---|---|---|
| Add a loan stage the origination system already uses | Configuration | Picklist values are customer-editable by design. | Keep it reconciled with the field map. |
| Send the listing agent a different milestone set | Already possible, unbuilt | The recipient matrix is configuration on every rollout. | None beyond the Flow itself. |
| Escalate a file stalled more than five days | Configuration | A scheduled Flow with an SLA clock covers it. | One Flow, documented and versioned. |
| Roll partner profitability over three years of funded volume | Configuration | Custom report type plus roll-up or formula fields. | Metric definitions must stay documented. |
| Recalculate pricing across 40,000 contacts nightly | Development | Volume exceeds what declarative tools handle reliably. | Apex with test coverage and a deployment path. |
| Push data to a lender system with no connector | Development | Needs an authenticated callout and error handling. | Integration code, monitoring and retry logic. |
| Give partners a self-service view the portal does not ship | Development | Experience Cloud work past shipped behaviour. | Portal components plus a compliance review. |
Everything here is built beside the managed package, released through a sandbox, and documented so the next person can change it.
The data model extended to carry what your firm actually tracks, without touching the managed package internals.
Automation past the shipped templates — built to a standard, documented, and released through a sandbox rather than straight into production.
Real development, where the admin tools genuinely run out — quoted separately and only when the requirement justifies the maintenance.
The referral-partner experience pushed past its shipped behaviour — carefully, because some of its controls touch compliance.
Report types and dashboards that answer the questions your leadership actually asks, rather than the ones the shipped reports happen to cover.
The work that makes every later change cheaper — usually the highest-return engagement in an org that has been live a few years.
Classify first. It is the step that most often removes the project entirely, which is exactly why it goes first.
Configuration, development, or already-possible-and-unbuilt. This is the cheapest step and it changes the price of everything after it.
Automation inventory on the affected objects, so we extend rather than collide — and so nothing gets built twice.
The approach, the maintenance it creates, and a separate price for anything that crosses into real development.
Built and tested away from production, including a regression pass over the origination sync and the milestone Flows.
Deployed through a managed path, with architecture notes and a change-log entry, so whoever inherits it can change it safely.
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.
Salesforce CPQ with Apollo.io enrichment, Outreach sequences and Zapier workflow automation across one connected sales stack.
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.
Sales operations and lead management rebuilt on Salesforce, from lead routing through to contract generation and commissions.
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.
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.
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.
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.
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.
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.
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.
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