Learn Aura Components: Maintain and Migrate Salesforce Lightning Aura Code

If you need to learn Aura components, it's almost certainly because you're maintaining, extending or migrating an org that already uses them. Let me be straight about it: Lightning Web Components is the default for all new Salesforce UI work, and you should learn LWC first. But Aura still powers a lot of production orgs, and someone has to understand it. The two courses above cover Aura fundamentals, Lightning Data Service, events, navigation, button overrides, multi-step forms and security, all built live in a real org.

What Aura is and where you still meet it

Aura was Salesforce's first Lightning component framework, and it powered Lightning Experience before LWC arrived. An Aura component is a bundle: .cmp markup, a client-side controller, a helper, optional renderer and style files, and an Apex controller on the server.

On projects today, you meet Aura when:

• Maintaining existing orgs. Many orgs built their Lightning UI before LWC existed, and that code still runs in production.
• Migrating to LWC. You can't rewrite what you can't read, and a good migration starts with understanding the Aura component's events and data flow.
• Wrapping LWCs. A few contexts have historically needed an Aura wrapper around an LWC, such as some standard button overrides. Check the current documentation for your target, because Salesforce keeps adding LWC support.
• Reading old packages. Managed and unmanaged packages from a few years ago are often Aura.

For new components, I build in LWC. That's not a style preference: LWC is standards-based, faster, and where Salesforce adds new capabilities.

Prerequisites

• JavaScript. Aura controllers and helpers are JavaScript, and the free JavaScript for LWC course covers what you need.
• Apex basics, for the server-side controller. See Apex.
• Ideally, LWC. If you know LWC, Aura's concepts map across quickly and you'll understand why LWC made the choices it did.

What you'll be able to do afterwards

• Read and debug any Aura component bundle in an existing org
• Build components with attributes, controllers, helpers and Apex controllers
• Communicate with component events and application events, and know which to use
• Use Lightning Data Service in Aura with force:recordData
• Override standard buttons and build multi-step form wizards
• Plan a migration of Aura components to LWC, piece by piece

A hands-on example: the same component in Aura and LWC

Here's a small Aura component that loads recent accounts from Apex.

<aura:component controller="AccountListController" implements="flexipage:availableForAllPageTypes">
    <aura:attribute name="accounts" type="Account[]" />
    <aura:handler name="init" value="{!this}" action="{!c.doInit}" />

    <lightning:card title="Recent accounts">
        <aura:iteration items="{!v.accounts}" var="acc">
            <p class="slds-p-horizontal_small">{!acc.Name}</p>
        </aura:iteration>
    </lightning:card>
</aura:component>

({
    doInit: function (component, event, helper) {
        helper.loadAccounts(component);
    }
})

({
    loadAccounts: function (component) {
        const action = component.get('c.getRecentAccounts');
        action.setCallback(this, function (response) {
            if (response.getState() === 'SUCCESS') {
                component.set('v.accounts', response.getReturnValue());
            } else {
                console.error(response.getError());
            }
        });
        $A.enqueueAction(action);
    }
})

The first block is the markup, the second the controller and the third the helper. getRecentAccounts is a static @AuraEnabled(cacheable=true) method on AccountListController.

What to notice:

• v. and c. mean different things in different places. In markup, v.accounts is an attribute and c.doInit is a client-side controller action. In JavaScript, component.get('c.getRecentAccounts') is the server-side Apex method.
• Controller versus helper. The controller handles events and delegates. Reusable logic belongs in the helper, which other controller actions can share.
• Apex calls are queued. $A.enqueueAction batches server actions, and the callback receives a state you have to check.

The LWC version of the same thing is a few lines: @wire(getRecentAccounts) accounts; in the class, and lwc:if and for:each in the template. Seeing them side by side is the fastest way to understand why LWC replaced Aura for new work.

Common mistakes when working with Aura

1. Starting new features in Aura because the org already has some. New work should be LWC, even inside an Aura-heavy org. An Aura parent can host an LWC child.
2. Updating components from outside the Aura lifecycle. Code in setTimeout, promises or third-party callbacks needs $A.getCallback(), or the component won't re-render.
3. Overusing application events. They're broadcast to everything that listens. Use component events for parent-child communication, and Lightning Message Service for communication between unrelated components.
4. Putting logic in the controller. It can't be reused. Move it to the helper.
5. Not handling the ERROR and INCOMPLETE states of a server action.
6. Big-bang migrations. Rewriting a whole Aura app at once is risky. Migrate the leaf components to LWC first and keep the Aura shell until the end.

Migrating an Aura component to LWC: the order I use

When a team asks me to migrate Aura, I don't start by rewriting anything. I start by mapping the component:

1. List its inputs and outputs. Every aura:attribute that a parent sets becomes an @api property in LWC. Every event it fires or handles needs an LWC equivalent: a custom event for parent-child communication, or Lightning Message Service for unrelated components.
2. Find the Apex it calls. Cacheable @AuraEnabled methods can usually be reused as they are, through @wire or an imperative import.
3. Check where it's used. Lightning pages, quick actions, overrides, Experience Cloud and other components. Some of these places may need an Aura wrapper to stay.
4. Rebuild the leaves first. Replace the smallest child components with LWCs inside the existing Aura parent, test, and release. Then work upwards.
5. Delete the Aura bundle last, once nothing references it.

Moving one component at a time keeps every release small and every regression easy to trace.

How Aura connects to the other topics

• Lightning Web Components is the main topic. Aura is the legacy companion you learn alongside it.
• Both depend on Apex for server logic and on JavaScript.
• Interview questions on Aura usually appear in LWC rounds as "how is this different in Aura?", so practise with LWC interview questions.
• The Salesforce developer roadmap treats Aura as optional, for when your job needs it.

Who should skip this

• Skip it if you're new to Salesforce development and your org doesn't use Aura. Learn LWC.
• Skip it if you only build new features in an org with no Aura code.
• Learn it if your job involves an older org, an Aura-to-LWC migration, or a package that ships Aura components.

There are no refunds, so judge the teaching with the free JavaScript for LWC course first.