Salesforce’s reputation for requiring expensive developer resources to customise is outdated – the platform’s declarative toolset now covers the large majority of what most companies need, from custom fields and page layouts to complex multi-step automation and approval workflows, all without a line of code. The distinction that matters: declarative customisation (point-and-click configuration using Salesforce Setup tools) versus programmatic customisation (Apex code, Lightning Web Components, Visualforce). This guide covers every major declarative customisation capability in Salesforce 2026, what you can accomplish without writing code, and where you genuinely need a developer.
That is what makes configuration such a valuable admin habit.
When the structure is planned well, the CRM stays easier to maintain even as the team changes fields and layouts over time.
The best guide is the one that turns customisation into a controlled process.
A practical explanation should help the reader think about usability, structure, and future flexibility together.
That means the guide should show how admins can make the system fit the business without overengineering it.
For many teams, the appeal is being able to improve the CRM while keeping the setup more manageable.
It should also help readers understand the line between configuration and deeper custom development.
A good guide should explain what can be changed safely and why that matters for maintainability.
That makes no-code customisation a core admin skill.
How to customise Salesforce CRM without code is a useful topic because many teams want to adapt the platform without waiting for developers. Salesforce offers configuration tools that can shape layouts, fields, and workflows without writing custom code.
That is what makes configuration such a valuable admin habit.
When the structure is planned well, the CRM stays easier to maintain even as the team changes fields and layouts over time.
The best guide is the one that turns customisation into a controlled process.
A practical explanation should help the reader think about usability, structure, and future flexibility together.
That means the guide should show how admins can make the system fit the business without overengineering it.
For many teams, the appeal is being able to improve the CRM while keeping the setup more manageable.
It should also help readers understand the line between configuration and deeper custom development.
A good guide should explain what can be changed safely and why that matters for maintainability.
That makes no-code customisation a core admin skill.
How to customise Salesforce CRM without code is a useful topic because many teams want to adapt the platform without waiting for developers. Salesforce offers configuration tools that can shape layouts, fields, and workflows without writing custom code.
That is what makes configuration such a valuable admin habit.
When the structure is planned well, the CRM stays easier to maintain even as the team changes fields and layouts over time.
The best guide is the one that turns customisation into a controlled process.
A practical explanation should help the reader think about usability, structure, and future flexibility together.
That means the guide should show how admins can make the system fit the business without overengineering it.
For many teams, the appeal is being able to improve the CRM while keeping the setup more manageable.
It should also help readers understand the line between configuration and deeper custom development.
A good guide should explain what can be changed safely and why that matters for maintainability.
That makes no-code customisation a core admin skill.
How to customise Salesforce CRM without code is a useful topic because many teams want to adapt the platform without waiting for developers. Salesforce offers configuration tools that can shape layouts, fields, and workflows without writing custom code.
The Salesforce Setup Menu: Where All No-Code Customisation Lives
All declarative Salesforce customisation happens in Setup – accessible via the gear icon in the top-right corner of any Salesforce page. Setup is organised into three main areas:
- Administration: Users, profiles, permission sets, roles, organisation settings
- Platform Tools: Object Manager (custom fields, page layouts, record types), Flow Builder, Process Builder (legacy), approval processes, Lightning App Builder
- Einstein and AI: Einstein feature configuration, Agentforce setup
The Object Manager is the starting point for almost all data model customisation; Flow Builder is the primary automation tool; Lightning App Builder handles UI customisation. Master these three tools and you can handle the majority of Salesforce customisation requests without code.
Custom Fields and Data Model Customisation
Creating Custom Fields
Navigate to Setup ? Object Manager ? [Object Name] ? Fields & Relationships ? New. Salesforce supports 20 custom field data types:
- Text: Single-line text (up to 255 characters)
- Text Area: Multi-line text (up to 131,072 characters)
- Number: Numeric values with defined decimal places
- Currency: Monetary values – automatically respects the org’s currency settings and multi-currency configuration
- Percent: Percentage values
- Date and Date/Time: Calendar date with or without time component
- Checkbox: True/false boolean field
- Picklist: Single-select dropdown list with defined values
- Multi-Select Picklist: Allows multiple values to be selected simultaneously
- Lookup Relationship: Links one record to another object – loose relationship (deleting the parent does not delete the child)
- Master-Detail Relationship: Parent-child relationship where the child record cannot exist without a parent – enables roll-up summary fields
- Roll-Up Summary: Calculates COUNT, SUM, MIN, or MAX of child records in a master-detail relationship – e.g., total value of all Opportunity line items on an Opportunity, or count of open Cases on an Account
- Formula: Calculated field that derives its value from a formula using other field values, mathematical operations, date functions, and text functions – recalculates dynamically without storing a static value
Formula Fields: The Most Powerful No-Code Tool
Formula fields unlock derived data that would otherwise require code. Examples:
- Days since last activity:
TODAY() - LastActivityDate– shows how many days have passed since a rep last logged an activity on an account - Opportunity age:
TODAY() - CreatedDate– how long the opportunity has been open - Days to close:
CloseDate - TODAY()– urgency indicator for the rep - Discount percentage:
(1 - (Amount / NULLVALUE(List_Price__c, 1))) * 100– calculates discount from list price vs. actual deal amount - Commission estimate:
IF(StageName = "Closed Won", Amount * Commission_Rate__c, 0)– shows estimated commission only for closed deals - Health score colour: Using IMAGE() and IF() functions, display a red/yellow/green icon based on a health score field value – visual indicators without code
Page Layouts and Record Types
Page Layouts
Page layouts control which fields appear on a record, their order, which fields are required, which are read-only, and which related lists appear at the bottom of the page. Layouts are assigned per profile – sales managers can see different fields than SDRs on the same Opportunity record. Configure via Setup ? Object Manager ? [Object] ? Page Layouts.
Lightning Record Pages (Lightning App Builder)
Lightning Record Pages replace older page layouts with a component-based drag-and-drop interface. Access via Setup ? Lightning App Builder or by clicking the gear icon on any record and selecting “Edit Page”. Components available for placement:
- Record Detail (standard field display)
- Related Lists (associated child records)
- Chatter Feed
- Activities (tasks and events)
- Einstein Next Best Action
- Highlights Panel (compact layout fields in the page header)
- Any AppExchange managed package components installed in the org
Dynamic Forms (available on Custom Objects and now most Standard Objects) allow individual fields to be placed anywhere on the Lightning page, not just inside the standard Record Detail component. Dynamic Visibility rules on Dynamic Forms show or hide individual fields based on field values, record type, or user profile – creating context-sensitive forms without code.
Record Types
Record Types allow different subsets of the same object to have different page layouts, picklist values, and assigned processes. A practical manufacturing example: an Opportunity Record Type of “New Equipment” shows configuration and technical fields; “Aftermarket Service” Record Type shows warranty, serial number, and maintenance fields. Same Opportunity object, different data entry experience per deal type – entirely no-code via Setup ? Object Manager ? [Object] ? Record Types.
Flow Builder: Salesforce’s No-Code Automation Engine
Flow Builder (Setup ? Process Automation ? Flows) is the most powerful no-code tool in Salesforce – it handles automation that previously required Apex triggers or the now-deprecated Workflow Rules and Process Builder. Flow types available:
- Record-Triggered Flow: Fires when a record is created, updated, or deleted – the replacement for Workflow Rules. Example: when an Opportunity stage changes to “Closed Won”, automatically create an onboarding Task, update the Account’s “Total Won Deals” counter, and send a Chatter notification to the Account owner
- Schedule-Triggered Flow: Runs on a defined schedule against a batch of records. Example: every Sunday night, find all Opportunities with a Close Date in the past week that are still in “Proposal” stage and create a follow-up Task for the owner
- Screen Flow: Interactive guided process presented to users as a step-by-step wizard. Example: a “New Customer Onboarding” wizard that walks service reps through creating the Account, Contact, Service Contract, and initial Task in a single guided interface – replacing a multi-tab, multi-object manual process
- Auto-Launched Flow: Triggered from another Flow, a REST API call, or an Apex class – used for sub-process reusability
- Platform Event-Triggered Flow: Fires in response to a Platform Event – integration-pattern flows for event-driven architectures
What Flow Builder Can Do Without Code
- Create, update, and delete records across any objects
- Query related records and loop through result sets
- Send email alerts (using Salesforce Email Templates)
- Post to Chatter
- Send custom push notifications to the Salesforce Mobile App
- Call external REST APIs via HTTP Callout actions (new in recent Salesforce releases – previously required Apex)
- Invoke other Flows as sub-flows
- Launch Approval Processes
- Assign permission set licences
- Create Salesforce tasks and calendar events
Approval Processes
Approval Processes (Setup ? Process Automation ? Approval Processes) manage multi-step review and approval workflows for records without code. Typical uses:
- Quote discount approval: quotes above 15% discount require VP Sales approval; above 25% require CEO approval – multi-level approval with automatic routing based on discount percentage
- New Account approval: newly created accounts require territory manager review before outreach begins
- Contract approval: contracts above a defined value route to Legal for review before sending to the customer
Approvers receive email notifications or Salesforce Mobile App push notifications, can approve or reject with a comment, and the record’s status field updates automatically based on the decision. Approval history is tracked on the record for full audit trail.
Validation Rules
Validation Rules (Setup ? Object Manager ? [Object] ? Validation Rules) use formula syntax to prevent records from being saved in an invalid state. Examples:
- Require Close Date to be in the future when creating a new Opportunity:
AND(ISNEW(), CloseDate < TODAY()) - Require a Loss Reason when an Opportunity is closed lost:
AND(ISPICKVAL(StageName, "Closed Lost"), ISBLANK(Loss_Reason__c)) - Prevent stage regression without manager approval:
AND(ISCHANGED(StageName), ISPICKVAL(StageName, "Qualification"), ISPICKVAL(PRIORVALUE(StageName), "Proposal"))
Reports and Dashboards
Salesforce Reports and Dashboards are entirely no-code and represent some of the most powerful no-code analytics available in any CRM:
- Report Builder: Drag-and-drop report creation across any objects – tabular, summary, matrix, and joined report types. Filters, groupings, and cross-object fields accessible without SQL or code
- Dashboard Builder: Assemble up to 20 dashboard components (charts, tables, gauges, metrics) from report data sources into a visual management dashboard – accessible to any user with dashboard permissions
- CRM Analytics (Einstein Analytics): For more complex data visualisation and AI-driven analytics (available with Einstein 1 and certain add-on licences) – provides interactive dashboards with drill-down, predictive analytics, and embedded AI insights beyond standard Reports
Where You Actually Need a Developer
Honest assessment of what genuinely requires Apex code or Lightning Web Components:
- Complex business logic with multiple conditional branches that exceed Flow’s performance limits (very high volume trigger scenarios)
- Custom UI components that cannot be achieved with standard Lightning page components – e.g., a custom interactive map, a complex data table with inline editing, a custom calendar view
- Deep integration with external systems requiring authentication flows, webhook handling, or complex API response parsing beyond what Flow HTTP Callout actions support
- Bulk data processing jobs that must handle millions of records (Apex Batch jobs)
- Real-time event streaming to external systems using Platform Events with complex transformation logic
For the vast majority of companies under 200 Salesforce users, a skilled Salesforce Administrator – a non-developer with Salesforce Administrator and Advanced Administrator certifications – can handle 80-90% of customisation requirements entirely through declarative tools. Developer investment is justified for the remaining 10-20% of complex integrations and custom UI requirements.
No-Code Customization: Advanced Techniques for Salesforce Admins
What is the difference between Salesforce page layouts and Lightning App Builder?
Salesforce page layouts define which fields, related lists, and custom links appear on a record view. Lightning App Builder defines which Lightning components and panels appear on the overall page surrounding those fields. They work together but serve different purposes: the page layout controls the field section (the grid of fields in the details tab), while the Lightning App Builder controls all other sections of the page (activity timeline placement, related list placement, custom components). When admins say they are customizing a page layout, they typically mean both: editing the field arrangement in the page layout editor AND editing the overall component placement in the Lightning App Builder. Dynamic Forms (Enterprise and above) blur this boundary further by allowing field visibility conditions to be configured directly in the Lightning App Builder instead of relying on separate page layouts per Record Type.
How many custom fields can you have in Salesforce?
Salesforce enforces limits on custom fields per object. Standard objects (like Account, Contact, Opportunity) allow up to 500 custom fields each. Custom objects allow up to 500 custom fields per object. Formula fields have a separate sublimit of 100 per object. For most organizations, these limits are not restrictive — orgs rarely approach 500 custom fields on any single object. However, orgs that have been using Salesforce for many years without field governance often accumulate hundreds of low-value fields and may benefit from archiving or deletion of obsolete fields to improve performance and maintainability. Salesforce does not allow deleting custom fields if they are referenced by Apex code, Formula fields, Validation rules, or Workflows — you must remove all references first before deletion is possible.
Can you undo customization changes in Salesforce?
Salesforce does not have a universal ‘undo’ for configuration changes. Changes made in the Salesforce Setup menu (adding fields, editing page layouts, modifying automation rules) are applied immediately and most cannot be automatically reverted. Best practices to protect against accidental configuration changes: (1) Always make configuration changes in a Sandbox environment first, test thoroughly, then deploy to production using Change Sets or Salesforce CLI — this creates a separation between your ‘staging’ configuration and live org. (2) For critical configuration changes, take screenshots or export configuration details before making changes so you can manually recreate the prior state if needed. (3) Enable Setup Audit Trail (available automatically in all Salesforce orgs) which logs every configuration change with timestamp and user — useful for identifying what changed if unexpected behavior occurs after a configuration session.
What Salesforce admin tools work without any coding knowledge?
Salesforce’s declarative (no-code) toolset includes: Flow Builder for automation (create record-triggered automations, screen flows, scheduled automations), Validation Rules for data quality enforcement, Formula Fields for calculated field values, Object Manager for custom fields and relationships, Page Layout Editor and Lightning App Builder for record page design, Reports and Dashboards Builder for analytics, Approval Processes for multi-step approvals, Assignment Rules for automated record routing, and AppExchange for installing pre-built apps. Salesforce is deliberately designed so that 80-90% of CRM customization requirements can be met without writing code. Apex code (Salesforce’s programming language) is needed only for complex batch processing, custom REST API development, and highly specific trigger logic that cannot be expressed declaratively.
Problem: Custom Fields Accumulate Cluttering Page Layouts and Confusing Users
Over time, Salesforce admins create custom fields for every new business request without retiring old ones. Page layouts accumulate dozens of fields, many of which are rarely populated, and new users feel overwhelmed by the complexity. To manage field sprawl: (1) Conduct an annual field audit using Salesforce’s free Field Trip app (AppExchange) which reports field population rates — any field with less than 10% population across records over 90 days is a candidate for deprecation or layout removal. (2) Use Dynamic Forms (available on Enterprise and above) to show fields conditionally based on Record Type, user profile, or field values — this dramatically reduces visual clutter by showing only relevant fields for each context. (3) Establish a ‘field governance process’: any new custom field request must include a business owner responsible for its data quality, a planned population rate target, and a review date. This prevents uncontrolled field proliferation.
Problem: Validation Rules Create Unexpected Blocking Errors During Data Migration
Validation rules that enforce data quality for live data entry can inadvertently block data migration imports when legacy data doesn’t meet the new validation criteria. For example, requiring a ‘Phone’ field in a specific format blocks importing contacts from a system that stored phone numbers in a different format. To manage validation rules during migrations: (1) Before any data import, review all active validation rules on the target object and identify which rules might conflict with your import data format. (2) Temporarily bypass (but not delete) non-critical validation rules during migration by adding a condition that checks if a special ‘Migration Mode’ custom field is set to True — the admin sets this field for import batches, bypassing the rule temporarily. (3) After migration is complete, remove the bypass condition and validate your imported data against the rules to identify records that need cleanup, rather than discovering them during a live import that aborts mid-process.
Problem: Record Types Are Misconfigured and Show Wrong Page Layouts to Users
Salesforce Record Types control which page layout, picklist values, and processes apply to specific record categories. Misconfigured Record Types — where the wrong page layout is assigned to a user profile, or where Record Types are assigned to profiles that shouldn’t see them — result in users seeing wrong fields, wrong picklist options, or being prompted to select a Record Type they don’t need. To audit and fix Record Type assignments: (1) In Setup > Object Manager > select object > Record Types, review every Record Type’s page layout assignment matrix — each row represents a profile, each column represents a Record Type. (2) Remove Record Type assignments from profiles that don’t use them — users should only be offered Record Types relevant to their role. (3) If all users use the same Record Type, consider removing extra Record Types entirely rather than leaving them active but unassigned, which reduces confusion during record creation.
The best no-code setup is the one that improves the CRM without making it harder to maintain. If the changes are too loose, the structure can get messy fast.
The best no-code setup is the one that improves the CRM without making it harder to maintain. If the changes are too loose, the structure can get messy fast.
The best no-code setup is the one that improves the CRM without making it harder to maintain. If the changes are too loose, the structure can get messy fast.