Mastering Dynamic Visualforce in Salesforce: The Art of Responsive Classic UIs
In the fast-evolving world of Salesforce development, Lightning Web Components (LWC) and the Lightning Experience often steal the spotlight. However, for many organizations still working in or supporting Classic Salesforce, Visualforce remains a critical part of their architecture. But did you know that Visualforce can be dynamic and adaptive, too?
Welcome to the world of Dynamic Visualforce—a powerful technique that brings flexibility, responsiveness, and intelligence to traditional Visualforce pages.
What Is Dynamic Visualforce?
Dynamic Visualforce refers to building Visualforce pages that change behavior, content, or structure at runtime, based on user input, data values, or metadata. Unlike static Visualforce pages that show the same layout to everyone, dynamic pages adapt—making your UI more personalized, powerful, and relevant.
Why Use Dynamic Visualforce?
Dynamic Visualforce is ideal when you want to:
- Build generic admin pages for multiple objects
- Show or hide components based on user roles or permissions
- Render fields dynamically based on metadata or configuration
- Offer custom experiences without duplicating pages for each use case
Techniques for Creating Dynamic Visualforce
Let’s dive into the common techniques developers use to build dynamic Visualforce pages:
- Conditional Rendering
Use the rendered attribute to conditionally display components based on controller logic.
<apex:outputPanel rendered=”{!IF(UserRole == ‘Admin’, true, false)}”>
<apex:commandButton value=”Delete Record” action=”{!deleteRecord}”/>
</apex:outputPanel>
This is useful for permission-based rendering or toggling UI elements.
- Dynamic Components in Apex
Visualforce offers a set of classes like Component.Apex.* that allow you to programmatically create components in your Apex controller.
Example:
public Component.Apex.OutputText createDynamicText() {
Component.Apex.OutputText text = new Component.Apex.OutputText();
text.value = ‘Welcome to Dynamic Visualforce!’;
return text;
}
Then bind it to your page using:
<apex:dynamicComponent componentValue=”{!createDynamicText}”/>
- Schema-Based Field Rendering
You can use Schema.DescribeFieldResult and Schema.SObjectType to dynamically display fields based on object metadata.
Example:
<apex:repeat value=”{!fieldList}” var=”field”>
<apex:inputField value=”{!record[field]}”/>
</apex:repeat>
This is useful for building generic data entry forms.
- Dynamic Binding via Maps
If you don’t know field names at compile time, use maps in Apex:
<apex:inputText value=”{!fieldMap[‘Email’]}”/>
This enables data-driven layouts that can adapt to user preferences or configuration.
Use Case: Generic Object Manager Page
Let’s say you want to build a single page that can view and edit any custom object. You could:
- Accept the object API name as a URL parameter.
- Use Schema.getGlobalDescribe() to retrieve fields.
- Dynamically render fields using <apex:repeat>.
- Save the record using a dynamic SObject.
This creates an admin-friendly, metadata-driven interface with a single Visualforce page and controller.
Things to Keep in Mind
- Security First: Always check field-level security (FLS) and object permissions.
- Performance: Overusing dynamic Apex logic can lead to slower pages.
- Maintainability: While flexible, dynamic pages can become hard to debug. Use clear naming and comments.
The Future: Dynamic Visualforce vs Lightning
Dynamic Visualforce is not a replacement for Lightning Components, but it fills an important gap:
| Use Case | Visualforce | Lightning |
| Legacy system extensions | ✅ | ❌ |
| Metadata-driven admin tools | ✅ | ✅ |
| Mobile-first, modern UI | ❌ | ✅ |
| Dynamic field rendering (Classic) | ✅ | ✅ |
If you’re working in Classic, or maintaining hybrid environments, Dynamic Visualforce lets you stay agile and scalable.
Final Thoughts
Dynamic Visualforce empowers developers to build smarter, more adaptive UIs within the Visualforce framework. Whether you’re showing a custom button only to admins, generating fields based on object type, or building a metadata-driven interface, these techniques offer tremendous power.
While Lightning is the future, Visualforce is still very much alive—and when combined with dynamic logic, it becomes far more than a static UI layer.