Advanced Elements - WordPress Plugin

A Practical Guide to Using Advanced Elements for Dynamic Elementor Pages

Advanced Elements is useful when Elementor’s standard dynamic fields are no longer enough. You may need to repeat Advanced Custom Fields data across multiple rows, pass it into a prebuilt template, connect it to other posts, or assemble a page from sections an editor is allowed to use. This guide goes beyond the plugin listing and walks through a working setup, from ACF field structure to a result you can verify on the public page.

The sections below cover environment preparation, installation, widget selection, and working with Repeater fields, dynamic tags, and Elementor templates. They also walk through a use case with Flexible Content and linked posts. The key point: Advanced Elements does not replace your ACF data model or design the site for you. It gives you a way to connect fields you have already planned to reusable Elementor layouts.

This guide is for site owners, content managers, and developers who want to make service catalogs, product cards, FAQs, team lists, course programs, specifications, or landing page sections editable without manually duplicating them. Each major step includes an action, the expected outcome, and a quick check, so you can catch issues before launch rather than afterward.

Where Advanced Elements Helps, and When You Can Do Without It

Think of the plugin as a bridge between data and presentation. In ACF, editors enter values such as a service name, price, image, description, link, status, list of benefits, or related content. Elementor handles the page layout: the grid, spacing, typography, and template display conditions. Advanced Elements comes in when the same set of fields needs to appear repeatedly or a data row needs to be rendered through its own Elementor template.

A typical example is a service with several packages. If a designer builds each package as a separate container on the page, updating the fields means editing several copies by hand. Instead, create an ACF Repeater with subfields such as title, description, price, link, and featured. The number of packages then becomes data. Advanced Elements can display those rows in a suitable widget: as a list, cards, a table, tabs, or a custom template. One layout handles every row, while the editor only needs to update the content.

This approach makes the most sense when three things are true: the content has a repeatable structure, visitors need a consistent presentation across entries, and the information will be updated after launch. Pricing, teams, schedules, specifications, related content, and FAQ sections usually fit the bill. A single block of text or a permanent banner usually does not; Elementor’s standard dynamic field or a regular container is simpler for those.

What the product is documented to do

Advanced Elements’ official page describes support for a wide range of ACF fields in Elementor, with a particular focus on ACF Repeater and Flexible Content, display widgets for Repeater fields, and dynamic tags. The publicly shown use cases include List, Accordion, Slides, Boxes, Table, displaying a Repeater through a template, and working with ACF Relationship and Post Object fields. This is more useful than a general promise of “dynamic content”: the plugin has a defined purpose, connecting structured ACF data to the Elementor interface.

The Repeater with Template feature deserves a closer look. It helps when the built-in display options do not fit and you need to create a custom card in Elementor. The plugin uses each Repeater row as context and applies the selected template to it. In that template, dynamic tags can pull subfield values from the current row. This connection makes it possible to build cards that combine images, text, buttons, icons, and conditional styling without writing a separate PHP loop.

Who it’s for

• Teams that plan their data first. Decide on field names and rules for entering data before you start building the card in Elementor.
• Sites with repeatable content. This includes services, plans, real estate listings, course programs, venues, recipes, staff, documents, product specifications, and help sections.
• Projects with distinct roles. A developer or designer sets up the fields and template once, then an editor adds rows through a clear ACF form.
• Sites that need controlled section choices. Flexible Content and templates reduce the chance that an editor will accidentally break a landing page’s structure.

When a simpler approach is better

There’s no need to build every page with Advanced Elements if the content is rare, unique, and easier to edit directly in Elementor. The plugin also can’t solve an undefined data structure. If your team does not yet know which data belongs in a card, sketch out the entity and test it with a few real entries first. Finally, Advanced Elements is not a replacement for a full catalog with filtering, complex queries, user accounts, or payment processing. Those tasks call for a separate architecture; Advanced Elements may still serve as the presentation layer.

Practical takeaway: don’t start in the widget panel. Start with one question: which fields will an editor need to fill in ten times, and why should those ten entries look the same? If you have a clear answer, the plugin can save time. If not, clarify the data model first.

How ACF, Elementor, and the Plugin’s Widgets Fit Together

It helps to understand where each tool’s responsibility begins and ends. ACF stores the structure and values. Elementor provides the editor and the place where you build the presentation. Advanced Elements picks up ACF data types that are difficult or inconvenient to display with Elementor’s standard features and makes them available to a widget as rows, the current related post, or a dynamic tag value. The public-facing site displays the finished output.

A simplified flow looks like this: ACF field group - post data - Elementor context - Advanced Elements widget or template - page. Each link in the chain has its own check. If a field is missing from the selection list, the problem is usually with the field group or preview context. If you can select the field but the page is blank, check the value in that specific post and the template’s display conditions. If the value is there but the layout looks wrong, check the selected widget, template, and theme styles.

This sequence helps avoid a common misconception: a blank card does not automatically mean the plugin is broken. The data may not have been saved, the field group may not apply to the right post type, the Elementor template may be previewing a different page, or the selected subfield may use an unsuitable return format. The sooner you separate the data from its presentation, the faster you can find the real cause.

Five product-specific mechanics to keep in mind

1. The Repeater provides the rows. The user adds an ACF row with subfields, and an Advanced Elements widget receives the rows and displays each one according to the same rules.
2. The widget determines the format. The same Repeater can appear as a table, list, accordion, cards, or slides. The entry itself stays the same; only the way visitors read it changes.
3. The template defines the markup contract. With Repeater with Template, the Elementor template does not store each card’s content. It gets values from the current row through dynamic tags.
4. Relationship and Post Object connect entities. Selecting another post in ACF creates a set of related objects that can be presented through a specialized template or dynamic tag.
5. Flexible Content provides a controlled set of sections. The editor chooses a layout and enters its subfield values, while a template mapped in advance builds the corresponding part of the page.

None of these mechanics removes the need for clear field names and instructions. Use readable machine names such as service_packages, package_title, package_price, and related_cases. Avoid renaming fields after launch without a good reason: templates and dynamic connections may depend on a specific field. The display label can be friendly and localized, but the technical name should remain stable.

A quick test before building the full layout

Create one test page or post of the required type. Add a small Repeater with two rows and two subfields: title and text. Save it, choose a simple Advanced Elements list widget, connect the correct field, and open the page in a new window. If both rows appear in the right order, the basic connection works. Only then add images, links, nested entities, and conditional styles. One small, verified use case is more reliable than a large layout where the source of an issue is hard to identify.

Before You Install: What to Check First

According to Goose Studio’s published listing, Advanced Elements is designed to work with Elementor Pro and Advanced Custom Fields Pro, and the requirements specify a compatible PHP environment. These requirements matter. Repeater and Flexible Content are advanced ACF field types, while dynamic content and Elementor templates rely on its expanded editing environment. Before installing, don’t rely on the plugin names alone. Open the admin dashboard and confirm that the required components are active on the site where you plan to build the template.

Check dependencies without risking the live site

1. Make a backup or work on a staging copy. This is especially important if existing Elementor templates already power your catalog or homepage.
2. Check that WordPress, the active theme, Elementor, Elementor Pro, and ACF Pro are in a compatible state. Avoid updating everything in one large batch right before publication.
3. Open ACF → Field Groups and confirm that you can create field groups and assign location rules to the required post type or page.
4. Open Templates in Elementor and confirm that your role can create the required template and set its display conditions.
5. Write down which content type will provide the data: Page, Post, WooCommerce product, or Custom Post Type. This determines where ACF displays the fields and which object to choose for the preview.

Permissions are easy to overlook. A developer may see the fields and templates while the content manager cannot access one of the panels or save the post. Before launch, ask the future editor to add two test rows and confirm that the labels make sense. If a field is for an image, have them upload one. If it stores a link, explain the expected format. This is easier than reworking the structure after handing over the site.

Design the post, not the editing screen

Start with a simple table on paper or in a working document: what entity are you describing, which values are fixed, which repeat, what is required, and what can be left blank? For example, a service page might need a fixed post title and introductory text, plus a service_packages Repeater with a name, description, price, link, and featured flag. For a team page, you might use a role, photo, and contact details instead of a price. For an FAQ, you need a question, an answer, and perhaps a topic tag. This prevents you from ending up with one universal Repeater full of fields that are rarely used.

Define what should happen when values are empty. If a row may have no image, its template must still look good without one. If the price is sometimes unknown, don’t leave a currency symbol by itself on the page. If a link is optional, don’t show a button with no destination. Advanced Elements displays the data you select, but decisions about missing values belong in the template design and Elementor conditions.

Compatibility and updates

The developer published a notice about a compatibility issue between Advanced Elements and a specific Elementor release and recommended temporarily holding off on updates to a live site until it had been tested. This does not mean the plugin is always incompatible with Elementor. It means you should update a stack of extensions on a copy of the site and check the critical templates. After an update, open a post with a Repeater, the Elementor template, the public page, a page with no data, and a page with the maximum number of rows.

A safe update sequence: backup or staging copy - update one set of components - check dynamic pages - then move the changes to the live site. If a widget disappears or a template goes blank after an update, roll back that specific change instead of changing fields on the live site.

Install and Run a First Test That Proves the Whole Setup

Install Advanced Elements through the standard WordPress process for a plugin archive you have already obtained: open Plugins → Add New → Upload Plugin, select the ZIP file, complete the installation, and activate the plugin. This guide does not cover purchasing, license keys, or ways to obtain the archive. After activation, don’t rush into building the real page. First confirm that the new widgets are available in the Elementor editor and that the ACF connection can see the test field group.

Your first verification path

1. Create or open a test post of the required type.
2. In ACF → Field Groups, add a group with a Repeater named test_items and two subfields: item_title and item_text.
3. Set a location rule so the group appears on that test post, save the group, and enter different values in two rows.
4. Open the post with Edit with Elementor, or assign it a separate Single template if you are building a template for a post type.
5. Find the Advanced Elements widgets, choose a simple list or Repeater widget, select test_items, and map the text and title fields using the available controls.
6. Save the page and open it in a private browser window so you can distinguish the public page from the editor preview and cached content.

This test should produce an observable result: two populated rows on the page, with text that matches what you entered in ACF. Don’t stop at seeing the widget in Elementor’s library. That confirms only that the interface was installed. A real test verifies the whole path: location rule, saved custom fields, post context, selected widget, and output on the public page.

If the field is missing from the control

Start by checking the context. Many issues occur when an Elementor template is edited without a preview page selected or with a post of a different type. That can look like a missing field. Set the preview to a post where the Repeater is already populated, save the selection, and reload the editor. Then check the ACF location rules: the field group must be assigned to the object you are working with, not merely exist in the admin dashboard.

Next, check the field type. A Repeater is not a single text field, so it should be selected where the widget expects a source of repeatable rows. An individual subfield is available within the row context or through a template’s dynamic tag. The problem “I can see the field, but not its child value” usually points to confusion between the parent Repeater and its subfields.

Ready to move on?

Before you start the main build, answer four questions: are the new widgets visible, can you see the test field group, do both rows appear, and are the rows different on the public page? If the answer to any question is no, don’t expand the project yet. Fix the basic connection first. Keep the test post until the full implementation is complete: it will be the fastest way to diagnose the issue if dynamic output stops working after an update or theme change.

After Installation: From Field Setup to a Reliable Page

Once the test connection works, move on to the main data model. Advanced Elements is configured across three places rather than in one global settings screen: the ACF field group, the selected widget’s controls, and the Elementor template settings. You can’t configure the last one properly if the first is still vague. Follow the chain in order: define the field structure, create a few plausible test posts, choose how to display them, and then work on the appearance.

Step 1. Build a field group that makes sense

Give each Repeater a label the editor will recognize and a brief instruction. List of Benefits is clearer than Block 2. Include only subfields that belong to the same repeatable entity. A benefit card might have a heading, description, icon or image, and link. A pricing row might have a name, explanation, price, and a flag for a featured plan. Don’t combine testimonials, plans, and information cards in one Repeater just because they all contain text.

ACF Repeater settings include minimum and maximum row counts, the display style in the admin panel, and an option to collapse rows by a selected subfield. Use these limits with a purpose. A minimum helps when the page should never display an empty block. A maximum keeps an unbounded list from overwhelming the editing screen and the page layout. Collapsing rows by item_title makes a long list easier to manage: editors see the headings instead of hundreds of open fields.

If a field is essential to the card, mark it as required in ACF. A card without a title, for example, usually has little meaning. But don’t make every field required. Optional images and links let you reuse the same data in other contexts. It’s better to design a clear state for missing values than to make editors enter fake links or placeholders.

Step 2. Add three different rows, not just one

One row does not test repetition. It can hide issues with the first or last card, different heading lengths, missing images, or an empty optional URL. Add at least three rows: one short, one long, and one that is incomplete in a way your setup allows. Add another with a long heading if that is realistic for your site. Now you’re testing more than data output; you’re checking that the interface can handle future content.

Avoid meaningless placeholder text. Realistic sample data is better at revealing issues. For a course program, enter module names, durations, and descriptions. For pricing, use realistic ranges and explanations. Don’t publish the test data: mark the post as a draft or work on staging. The test should reflect the editor’s future workflow, not just make the widget display a few words.

Step 3. Decide where the template belongs

You generally have two options. First, edit a specific page in Elementor if the list belongs only to that page. Second, create a template in Elementor Theme Builder and assign display conditions to the relevant post type. The second option works better for a catalog, service cards, or products because one template applies the same presentation to every post. It requires some discipline: the preview page needs real data, or it will be difficult to evaluate the dynamic controls.

In the template, start with the framework: container, grid, spacing, and section heading. Then add an Advanced Elements widget and choose the source field. Next, map the values. Don’t configure shadows, animations, or complex responsive exceptions until you can see the correct rows. Verify the data first, then polish the appearance. Otherwise, when output is blank, you won’t know whether the problem is the source or the styling.

Step 4. Keep a way to roll back

Before moving on to more complex templates, save the page and note which field, template, and test post are connected. Your team might record this in a task comment, project spreadsheet, or clear naming scheme: AE - Service package card, ACF - Service packages, Preview - Service Alpha. Clear names don’t affect the front end, but they make the setup much easier to maintain months later.

Settings to check first

Enable theme options, caching rules, or additional widgets only when you have confirmed that they’re needed. For example, a cache exclusion is not a default setting. It may be needed if you have confirmed that the admin editor shows a new value while the public page still serves the old one after a standard cache clear. Until then, don’t add exclusions; they can hurt performance without solving a problem.

Choose a Repeater Layout That Makes the Data Easy to Read

One Repeater does not dictate one widget. That flexibility is the key to a good interface. Before choosing a format, don’t ask, “Which element looks modern?” Ask, “How will visitors read or compare these rows?” A table works for consistent specifications that people scan by column. An accordion suits long answers that do not need to be open all at once. Cards work well for entries with an image and a distinct action. Slides make sense when the content is primarily visual and only one item needs to be in focus at a time.

Lists and rows

Choose List and similar row-based formats for benefits, files, short steps, menu items, and compact facts. Their strengths are a clear vertical rhythm and quick scanning. Their weakness is that they don’t handle large amounts of mixed content well. If a row includes an image, a long description, a price, two links, and several statuses, the list becomes an unwieldy column. In that case, switch to cards or a template.

In a row-based layout, lead with the value that helps the editor identify the item too: its title, file name, or staff member’s name. Put the explanation second. Make the link a clear, separate action rather than turning the whole paragraph into a link. After entering the data, check the page in a narrow browser window: long headings should not overflow or make the button hard to reach.

Accordions and tabs

Accordion works naturally for questions and answers, technical descriptions, terms, lesson programs, and other content where visitors choose which item to expand. In ACF, create separate subfields for the question and answer. Don’t store a finished accordion’s HTML markup in a field; that ties the data to one design and makes migration harder. The data should remain a question and an answer, while the widget handles the interaction.

Tabs work for a few equally important categories, but not dozens of rows. Too many tabs make navigation harder, especially on smaller screens. Before publishing, open the first, middle, and last tabs, check keyboard focus, and make sure color is not the only indicator of the selected tab. This is not a separate Advanced Elements feature; it’s a basic check of the interactive display.

Cards, image rows, and boxes

Image Rows, Image Boxes, Icon Rows, and Icon Boxes are useful when each row has its own visual identity. That might be a service with an icon, a team member with a portrait, a set of resources with cover images, or a list of steps. Set clear expectations for images. If some rows won’t have an image, the template should either use an icon neatly in its place or adapt without leaving an empty frame. Don’t make editors upload a random photo just to fill a slot.

Cards can run into a layout problem when headings and descriptions have different lengths. Don’t fix it by cutting off important text. First, give editors a reasonable character limit in the instructions. Then set up the card’s vertical layout so the button and key content appear in a predictable place. If equal heights are essential, test with the longest row. If they aren’t, let the cards vary in height rather than hiding content.

Tables

The Table widget makes sense for specifications, comparisons, schedules, documentation, and compact price lists. It’s a poor fit for expressive cards with images or sales copy. Before configuring a table, define what one row represents and what each column means. Readers shouldn’t have to guess what the column headings refer to. If some columns are available only to certain visitors, test both logged-in and logged-out access. The product’s official page says that cell display can vary based on login conditions.

Tables need a separate check on mobile screens. Don’t shrink everything until it’s unreadable. It may be better to limit the number of columns, add horizontal scrolling within the block, or show the same data as cards. The right choice depends on the data and the theme. Advanced Elements can display a table, but you’re still responsible for making it readable.

How to choose: base the display format on how visitors make decisions. If they compare columns, use a table. If they look for an answer, use an accordion. If they browse individual items, use cards. If they scan short points, use a list.

Repeater Templates: Build One Card and Keep the Current Row in Context

A ready-made widget works as long as its controls fit the task. If a card needs a custom layout, nested containers, a particular element order, or a combination of dynamic values, use Repeater with Template. The point is not to create multiple nearly identical templates. Instead, create one Elementor template for a row and have the widget apply it to every ACF Repeater row.

Define the row’s contract first

Suppose you’re building a list of service packages. Each row contains a name, short description, price, inquiry link, image, and Boolean field named featured. Before opening Elementor, write down which values are required. For example, a card cannot do its job without a name and link, while the image may be optional. That will help you decide on the element order. Don’t add fields to the card just because they’re easy to display.

In ACF, create a Repeater named service_packages and add its subfields. Add at least three packages to a test post. Give one a longer name than the others, leave the optional image empty on another, and mark the third as featured. This set lets you see whether the template handles real data rather than just an ideal demo.

Build an Elementor template for one row

Create a separate template with a clear name. Add the card container, heading, text, image, and button. In the supported controls, select a dynamic source and use the relevant Advanced Elements dynamic tags to display subfields from the current row. Don’t use the first row’s text as temporary static content. It’s easy to forget to replace a field and publish identical cards.

The source post should still be clear to the editor while working in the template. For the preview, use a test page with a populated Repeater. If the template appears blank in the editor, first confirm that the correct preview object is selected. Then check that the widget applying the template uses the same Repeater. The product’s official description directly connects Repeater with Template to dynamic tags and says it can be used for nested Repeater setups. A blank preview usually points to lost context, not a missing capability.

Connect the template to the Repeater

Return to the parent page or Single template. Add Repeater with Template, choose the Repeater source, and select the Elementor template you created. Set up the container, number of columns, or other available display options only after the template shows different values for all three rows. Open the public page and check more than the first card: the second item can reveal a repeated value, and the row without an image shows whether the template handles the missing space well.

This feature is especially useful when you want one consistent design without manually duplicating sections. The editor adds a row, and a new card appears according to the same rules. The designer updates the template, and the change applies to every card. That doesn’t mean you should change the template without testing: an update affects all the items, so check it on staging or a test post first.

Nested Repeaters: use them only when the data is truly hierarchical

Sometimes a row contains its own rows: a course program includes modules, and a module includes lessons; a menu includes categories, and a category includes dishes. ACF supports this structure. Public Repeater documentation and examples of alternative solutions confirm the underlying approach: a parent row has a child Repeater, which is displayed as a separate template level. But nesting makes the editing interface more complex and increases the chance of losing track of context.

Before creating a second level, ask whether the child object is a distinct repeatable entity and needs to be edited independently. If so, a nested Repeater may be appropriate. If not, one text field or a separate related post may be enough. Two levels of nesting call for especially careful preview and performance checks. Three or more usually suggest that the entities should be moved into a Custom Post Type or modeled another way.

Check the Repeater template

• The first, middle, and last rows show different values.
• A long heading does not break the grid or hide the action.
• A missing optional value does not leave an empty decorative frame.
• Each link uses the URL entered in its own row instead of repeating the first card’s URL.
• After you add a fourth row, exactly one more item appears on the public page.

If you only need to change the appearance, update the template and check every card. If you need to change the data structure, plan the migration first: new field names, moving values, and checks for empty rows. Don’t rename an active subfield on impulse. The connected template may keep looking for the old key and quietly display blank spaces.

Related Posts and Post Object: When a List Should Contain Separate Entities

A Repeater stores rows within one post. Relationship and Post Object fields solve a different problem: they connect one post to other WordPress content. It’s important not to confuse the two. Use a Repeater for one service’s specifications. For a curated set of case studies, doctors, related courses, documents, or recommended products, it usually makes more sense to link to standalone posts. Each related entity then has its own URL, image, metadata, and lifecycle.

ACF’s official documentation describes Relationship as a searchable field with filters for post type, status, and taxonomy. Depending on the selected Return Format, it can return a Post Object or a post ID. Advanced Elements’ official demos show dynamic tags and widgets for Relationship and Post Object fields, including template-based layouts. This lets editors choose related objects in ACF and display them on the public site using a consistent template.

Define what the relationship means

Before adding the field, decide who chooses the relationship and why. A service page might have a related_cases field for completed case studies. A course post might use recommended_courses to suggest the next topics. A real estate listing might use nearby_locations to link to neighborhoods. Name the field after its purpose, not its technology. Related is too vague; recommended_courses immediately tells the editor what it’s for.

Limit the available posts in the ACF field itself. If the relationship should include only case studies, filter by the relevant post type. If only published content should appear, don’t let editors accidentally select a draft. If order matters, don’t assume it will be right by default: select a few posts and check their order on the page. ACF field choices and rules are not cosmetic; they make the entire template more predictable.

Choose Post Object or Relationship based on the number of posts

Post Object is appropriate when you need one related post, such as an author, primary case study, lead specialist, or key document. Relationship makes sense when you may have several posts. Don’t turn a one-to-one connection into a list of one just for consistency. Likewise, don’t try to store several different roles in one Post Object field. A clear data model makes the template simpler: it knows whether to expect one object or a collection.

Check the Return Format in ACF. The template or dynamic tag must receive the type of value it expects. If you change the setting on a live site, test it on a copy first. Different formats affect which properties are available and how connected features interpret them. Don’t change the format by guesswork to make a list look different; the template controls appearance, while the return format controls how the data is passed.

Build a related-post card

Create a template that shows only what helps visitors choose a post: its title, cover image, short description, and link. Don’t display every metadata field just because it’s available. For case studies, visitors usually need the title, industry, outcome, and a link. For specialists, they need the person’s name, role, and profile card. Use the features provided by the selected Advanced Elements widget in the template and test each connection with two different related posts.

When using Relationship, it’s useful to test the reverse case: remove one selected post in ACF and save the page. On the public page, only that card should disappear; the others should remain. Then add a new post. It should appear without having to copy an Elementor container. This confirms the main reason to use a relationship: the data controls which items appear in the block.

The line between relationships and a catalog

Relationship works well for a manually curated selection by an editor. It is not a full query of all content based on complex conditions. If you need to show the latest posts in a category, products with a particular status, or filtered results, design a Query or Loop solution. Don’t manually select hundreds of posts in a Relationship field when the task should be automated. Advanced Elements helps display selected relationships, but it should not be used to work around WordPress architecture.

Check the data model: a Repeater stores parts of one post. Relationship and Post Object fields link to other posts. If an entity has its own URL and can be edited separately, it will usually need a relationship rather than a Repeater row.

Flexible Content and Templates: Let Editors Choose a Section Without Rebuilding the Page

ACF Flexible Content is a controlled set of layouts, each with its own subfields. It is not for unlimited freedom; it provides limited flexibility. The developer defines the available section types: a hero, information row, table, benefits block, gallery, FAQ, or quote. The editor chooses a layout and fills in only its fields. Advanced Elements can connect a particular Flexible Content layout to an Elementor template, so the output is a prebuilt section rather than a manually assembled layout on every page.

This feature is especially useful for landing pages with repeatable patterns. One page might need an introduction, service cards, and a table. Another might need an introduction, a video, and an FAQ. In both cases, the designer maintains a consistent interface while the editor rearranges approved content sections. The product’s official page describes this idea: connect an Elementor template to a specific Flexible Content layout to create different dynamic designs without building each product page in Elementor from scratch.

Design layouts around editorial choices

Each layout should clearly answer the question, “What block am I adding?” A layout named feature_cards means a grid of benefits. image_text means an image paired with text. faq means questions and answers. Don’t create a layout called section_01 that becomes a gallery on one page and a price list on another. That name helps neither the editor nor the next person maintaining the site.

Add instructions directly to the ACF interface. For example: “Add three to six cards. Keep the heading to two lines. Image is optional.” A prompt there does more to protect quality than an unwritten agreement in a team chat. Set minimum and maximum layout counts where the page should not be empty or overly long. Also decide whether a layout can be repeated. Sometimes repetition makes sense, but two similar blocks in a row often overwhelm the reader.

Map layouts to templates with a clear purpose

Name templates by meaning rather than by a specific page: AE - Layout - Feature cards, AE - Layout - Image text, AE - Layout - FAQ. Each template should use only the fields for its layout. If a layout contains a card Repeater, the nested template must use the context of that Repeater. Don’t assume a field with a similar name in another field group will automatically be available. Clear names and context reduce the chance of connecting the wrong source.

Start with two layouts, not ten. Check that the editor can add the first, fill it in, see the output, add the second, and get the expected page again. Then add more. This order helps uncover design issues: the wrong preview object, unnecessary required fields, unclear ordering, or templates without the right context.

Section order and the editor experience

Flexible Content is useful not because it offers a pretty list of layouts, but because it lets you control the sequence. If a marketing page should start with a hero, then provide supporting evidence, an offer, and an FAQ, explain that recommended flow in the editor’s instructions. You don’t have to forbid every other order, but you should show a good one. For complex pages, create a test post with every approved layout. It can serve as both an example for content managers and a regression test after updates.

Avoid hard-coding content in a template if editors are expected to change it. If the design includes a button label, there are two straightforward options: make the label permanent and say so in the instructions, or add a field for it. Hiding fixed text in the template and expecting editors to ask a developer to change it is the wrong approach. Flexible Content should reduce repeat work, not create it.

When Flexible Content gets too complicated

If one layout now has ten conditions, four different Repeaters, and dependencies on several external posts, stop and reassess. You may have built a mini page builder without good navigation. Split up the task: move standalone entities to a Custom Post Type, create a separate layout, or reduce the number of choices. A well-managed system is not the one with the most options; it’s the one a new editor can understand after a short explanation.

This principle matters especially with Advanced Elements: the plugin can display a complex model, but it does not remove the complexity from the data. The best Flexible Content layout is one an editor can fill out without knowing how Elementor works and a designer can update in one template without editing every page by hand.

Practical Example: A Service Page with Packages, FAQs, and Related Case Studies

Let’s walk through an implementation that brings together the main strengths of Advanced Elements. The goal is to create a service page template. Each service has a fixed title and introduction, several packages with prices and descriptions, an FAQ section, and a manually curated set of case studies. The content manager should be able to add and update this data in ACF. The designer should build the presentation once in Elementor. Visitors should see clear cards, expandable answers, and links to relevant case studies.

Step 1. Set up the fields and entities

Create or use a Custom Post Type named service. Add an ACF field group for it, with intro_title and intro_text fields if the main post content does not cover this need. Create a Repeater called service_packages with package_title, package_description, package_price, package_link, package_image, and package_featured. Add a separate Repeater called service_faq for the FAQ, with question and answer subfields. For case studies, add a Relationship field called related_cases and limit it to the case post type.

There’s a reason these are three separate fields: packages, FAQs, and relationships each have a different purpose, presentation, and set of checks. Don’t put questions in the same Repeater as packages even if you technically could. The editor would see a confusing form, and the template would need a series of empty-value conditions.

Step 2. Populate a test service

Create a test service and add three packages. Give the first a short name, the second a longer description and an image, and the third no image but a featured flag. Add five FAQ questions, including one with a long answer. Choose two case studies with different titles and cover images. This gives you enough content variations to design around without relying on fake placeholders.

Before moving on to Elementor, check the data in the ACF admin panel. Close the post and reopen it. If the rows were not saved or appear somewhere unexpected, fix the structure now. A template cannot compensate for values stored in the wrong custom fields.

Step 3. Create a template for one package card

Create a template called AE - Package card. Add an image, title, description, price, and button. Connect each value to the corresponding dynamic tag for the current row’s subfield. Confirm that the link comes from package_link, not from the parent service URL. Plan for the case without an image too: the container could hide the empty area or show a neutral background configured in the template.

Don’t add custom CSS or PHP just to make the card work. First see whether Elementor’s standard controls and the data can handle the task. A small, reversible CSS change makes sense only if the card already has a stable wrapper or a class that you added in Elementor. Since no publicly confirmed Advanced Elements CSS classes for this template are documented here, avoid inventing selectors in the hope of finding a universal fix.

Step 4. Build the service Single template

In Elementor Theme Builder, create or open a Single template for service. Start with the standard title and introduction. Then add Repeater with Template, choose service_packages, and select the card template. Below it, place a suitable Advanced Elements accordion widget and connect it to service_faq. In the last section, add a widget or template for related_cases. Set the preview to the test service and confirm that each section receives its own data.

Now set the display conditions. Apply the template only to the required post type, not the entire site. A condition that is too broad may display an empty dynamic block on a regular page that has no field group. After saving, open the test service at its public URL and compare the packages, FAQ, and case studies with the values entered in ACF.

Step 5. Check the output by changing the data

1. Add a fourth package and confirm that exactly one new card appears.
2. Reorder two packages in ACF and confirm that their order changes on the page if the selected widget follows the row order.
3. Remove the URL from the test button and check the planned state without a link.
4. Change an FAQ answer and refresh the page in a private window.
5. Remove one case study from the relationship and confirm that only its card disappears.

This example shows Advanced Elements’ main practical benefit: you change data instead of duplicating sections. If all five tests produce the expected result, the page is ready to hand over to the editor. If any test fails, don’t cover it up with a manual Elementor container. Return to the part responsible for that behavior: the field, post, template, widget, or display conditions.

Verify the Output for Editors, Visitors, and Search Crawlers

A dynamic block is not ready just because it looks right in the Elementor panel. Editors work with a preview, visitors see the public page, and search crawlers receive the final markup and links. These three views can differ because of caching, template conditions, access permissions, empty fields, or the theme. That’s why the final check should be brief but cover each perspective.

Check the editor experience

Open two real posts of the required type. Fill in as many fields as possible in the first and leave allowed optional fields blank in the second. The content manager should understand where to add a row, how to change the order, and which field controls each value. If they have to open Elementor just to change a package name or FAQ answer, the setup has missed its goal. If one accidental deletion can break the layout, rethink the available fields and instructions.

Check the order after dragging rows. It may be clear in the ACF interface, but the public page should follow the same order. Then change one row and confirm that the change did not appear in every card. This checks that the template reads the current row’s context instead of reusing one value.

Check the visitor experience

Open the page in a regular and private browser window, at a wide browser width and a narrow one. Check the beginning, middle, and end of the list. Make sure the headings are readable, buttons are accessible, and cards do not overlap. Expand several accordion answers in a row. Check how the table behaves at a narrow width. For slides, check that the controls are accessible and no important content stays hidden.

Check empty states separately. If a service has no related case studies, the section should either disappear cleanly or show a planned neutral state rather than an empty frame and heading. If a Repeater has no rows, the page should not show a widget with empty decorative spacing. This matters especially for templates applied to multiple posts of the same type.

Check the data and links

Compare the public page with the ACF post row by row. Each card’s name, description, price, image, and action URL should match. Click every link on at least one long post and one short post. For Relationship, compare the selected posts with the cards. This check may seem slow, but it is faster than finding out after publication that one incorrect dynamic tag sends every visitor to the wrong URL.

If you use images, check the alt text, dimensions, and crop. Advanced Elements does not make content accessible simply by making it dynamic. Images need meaningful values in the media library, links need clear action text, and interactive blocks need accessible visual and keyboard behavior.

Check the indexable output

Don’t promise that dynamic output will automatically improve SEO. Its practical benefit is that the site can have a consistent structure and current information when the data is filled in well. Open the page source or use the browser’s inspection tools to confirm that important headings, text, and links appear in the final markup. Don’t populate the Repeater with the same phrases just to increase the number of cards. The data should help visitors compare options, not create duplication.

For new dynamic templates, check the URLs of related content and make sure no test environment links are left behind. This is one of the few risks that may not be obvious from the layout after moving from staging to the live site. Also check that no draft comments from field instructions or test phone numbers appear in public text.

Final sign of success: the editor adds or changes data in ACF, only the expected element changes on the public page, and the design, links, and order remain manageable without manually copying Elementor sections.

Scale, Speed, and Maintenance: Keep a Convenient Setup from Becoming a Heavy Page

A Repeater is useful because the number of rows can grow. But more data changes the cost of editing and rendering. ACF’s official documentation warns that a large number of rows on the editing screen can put a load on the browser and PHP. Pagination reduces the number of rows loaded in the admin panel at once. This does not mean every long table is dangerous; it means you should plan for the size of the data and how often it will be edited.

Separate the editing load from the public-page load

ACF pagination helps with the editing screen, but it does not automatically change what a template or the REST API outputs. Don’t assume that enabling pagination will solve every speed issue on the public site. The page may still render every item, image, table, or slide you have added. For visitors, consider the number of cards, media file sizes, nested components, and third-party theme scripts.

If a list grows to dozens or hundreds of objects, ask whether it should still be a Repeater. A catalog with many standalone entries usually works better as a Custom Post Type with a query and pagination. A short benefits block with six rows is still a good fit for a Repeater. The decision depends not only on the number of items but also on whether each is a distinct entity: does it need its own URL, archive, author, taxonomy, search, filter, or revision history?

Set image guidelines

Cards with images often become the heaviest part of a page. Set a reasonable upload size, a consistent aspect ratio, and clear instructions for editors. Don’t upload huge originals if the card only shows a small cover image. Check that the theme and Elementor use suitable image sizes instead of loading the same original file for every placement. This is standard WordPress practice, but it matters especially with Repeaters: one mistake can be repeated twenty times.

Don’t add animation, a slider, and video to every row by default. First ask what each one is meant to accomplish. A short list of benefits is usually easier to read without motion. A large visual collection might call for slides, but then check keyboard access, image loading, and behavior on mobile. The ability to display a complex item does not mean you need to use one.

Agree on a maintenance plan

Leave brief documentation for each dynamic block: the source field, where the template lives, which post is used for the preview, which values are required, and what to do when an item is empty. Save this information in the project knowledge base or client documentation. Don’t leave it only in the developer’s head. Advanced Elements provides a convenient connection, but it remains useful when the next person can safely understand how it works.

Before updating plugins, use a test post with the fullest set of fields. Open it before the update and save a screenshot or list of expected blocks. Update on staging and compare the output. This is more practical than trying to remember every page after changing several extensions. If the update affects Elementor, ACF, or Advanced Elements, also check the template editor and dynamic tag selection.

Caching and dynamic updates

If an editor saves new values but the public page still shows the old ones, don’t immediately conclude that the connection is broken. First open the page in a private window and check when the post was saved. Then clear that specific page’s cache using the project’s normal process. If the site uses a CDN, check its rules too. Only then investigate the template. You don’t need global cache exclusions for every dynamic block: in this case, dynamic content is saved as page data and can usually be cached after it is rendered.

If the page shows different cells or elements to logged-in and logged-out visitors, as the product description says the Table widget can do, test both roles. This is a separate case. Make sure the caching system does not serve a logged-in visitor’s state to a guest or vice versa. If your project has no confirmed need for role-based differences, don’t add complicated cache rules in advance.

Advanced Elements Troubleshooting: Symptoms, Causes, Checks, and Safe Fixes

Dynamic block issues are easier to fix when you follow the flow of data. Don’t start by disabling extensions at random. First find where things diverge: in the ACF structure, the populated post, the Elementor context, the widget or template, the display conditions, or the published output. The issues below are characteristic of the Repeater, template, relationship, and Elementor setup.

The widget is available, but the field is missing from the selection list

Symptom: Advanced Elements appears in the Elementor panel, but the Repeater or related field is missing where you expect to select it. Likely cause: the template uses a different preview page, the field group does not apply to the current post type, the data has not been saved, or the selected control expects a single value rather than a parent Repeater.

What to check: open the test post and confirm that the field is populated and saved. Then set it as the preview object in Elementor. Return to ACF → Field Groups and compare the location rule with the post type. Check whether you’re trying to select a Repeater in a text control instead of a widget that accepts a list.

How to fix it: select the correct preview object, save the template, and reopen the editor. If the location rule is wrong, update it and save the test post again. When to roll back: if the field appeared only after temporarily changing the group, restore the intended rule instead of leaving it assigned too broadly across the site.

Every card repeats the first row’s data

Symptom: the number of cards is correct, but the heading, link, or image is the same on every card. Likely cause: the template is reading data from the parent page instead of the current subfield, or a value was entered as static content in the template.

What to check: use clearly different values in three rows, especially the URLs. Open each template control and confirm that the selected dynamic source is the current subfield. Check the button: it is often where a test page address or the parent’s general URL gets left behind.

How to fix it: replace static text and links with the corresponding dynamic tags, save the template, and reload the public page. When to roll back: if changing the tag makes every value disappear, restore the last working template, check its preview context, then change one control at a time.

The editor shows everything, but the public page is blank

Symptom: cards appear in the Elementor preview but not at the published URL. Likely cause: incorrect display conditions, caching, a different theme template applying to that post, or editing a template that is not assigned to this content type.

What to check: review the conditions in Theme Builder, open the page in a private window, and confirm that the URL belongs to the test post. Temporarily add visible but harmless text to the template and see if it appears at the public URL. Remove the text after the check.

How to fix it: narrow or correct the condition to the required post type and clear the specific page’s cache. If two overlapping templates are active, disable one on staging and confirm which should take precedence. When to roll back: if changing the conditions affects other parts of the site, restore the previous rule and set a more precise condition.

An empty image or button breaks the card

Symptom: some rows show an empty frame, the button leads nowhere, or there is a large blank space in the card. Likely cause: the field is optional, but the template assumes it will always have a value.

What to check: find a row with an empty ACF value and compare it with a complete row. Decide whether the content manager should always fill in that field. If so, make it required and add an instruction. If not, design a neutral state in the template.

How to fix it: remove the decorative container that only exists for a missing media file or use a planned neutral alternative. Don’t show an active button without a URL. When to roll back: if the field was required only because of the design, make it optional again and improve the template instead of forcing editors to add fake data.

An ACF change does not appear right away

Symptom: a new row is saved in the admin panel, but the public page shows the old state. Likely cause: page cache, browser cache, CDN, or editing the wrong post. Less often, the template is connected to a different source.

What to check: open the post in a new private window, check its URL and modification time, and clear the page cache through the usual process. Then change one short heading and see where it appears. If the new value shows up in an unexpected place, investigate the dynamic tag source.

How to fix it: use the normal cache-clearing process after changing important data instead of disabling caching across the site. If the issue persists after updating components, repeat the check on staging. When to roll back: if a global cache exclusion slows the site without fixing the problem, remove it and continue tracing the source.

Part of a template behaves differently after an update

Symptom: a previously working block is blank, warnings appear, or the editor no longer opens the expected controls. Likely cause: a compatibility change between Elementor, ACF, and Advanced Elements, an outdated widget, or a break in the saved values. Goose Studio’s knowledge base describes backward-compatibility cases and outdated widgets or tags, and the developer’s blog recorded a specific Elementor integration issue.

What to check: compare staging with a backup, open the test post, review plugin notices, and check which widgets are in use. Don’t delete fields or templates before diagnosing the issue. Check whether an outdated, separate option page widget or tag is in use when a newer general option already supports the source.

How to fix it: follow a migration path published by the developer only after making a backup. If the last update caused the issue and there is no clear fix, roll back only the changed component in a test environment and document what happened. When to roll back: do so immediately if the issue affects critical public pages and you have a tested previous set of versions.

When Advanced Elements Is a Good Fit

Advanced Elements makes sense when a site already uses ACF Pro and Elementor Pro, and its data needs to repeat, connect to other posts, or be assembled from controlled layouts. Its value is not the number of widgets but a repeatable workflow: the editor fills in the right fields, the template receives the right context, the widget displays the data in the right format, and visitors see a predictable block. The more carefully you design that connection, the less manual work remains after launch.

Start with one small use case: three Repeater rows, a simple widget or template, a test post, and a check on the public page. Then add Relationship fields, Flexible Content, and more complex layouts. This gradual approach keeps the setup manageable and gives you a clear way to roll back. If your task needs standalone catalog entities, automated queries, and complex filtering, evaluate a broader architecture first instead of expanding one Repeater indefinitely.

Once you have defined the data model, prepared a test post, and checked the required dependencies on a copy of the site, you can download the installation file and repeat the verification steps in your own environment. The most useful first release is not a large page with dozens of conditions, but a small dynamic block where every field, row, and change has an observable effect.