Classic to Kinetic, Custom UI Upgrade


+ Full Transcript

How to Convert Epicor Classic UI Customizations to Kinetic UI

Moderator: Good afternoon and thanks for joining us today. We’re talking specifically about uplifting Epicor Classic UI customizations to the Kinetic browser experience.

Our presenter today is Sam, Epicor Practice Director at 2W Tech and one of our go-to experts for Epicor ERP.

2W Tech is a full-service technology and managed services provider and has worked with Epicor solutions for more than 30 years across both manufacturing and distribution.

I’ll now turn things over to Sam.

Why Do Epicor Classic Customizations Need to Move to Kinetic?

Sam: Today, I’m going to walk through the uplift of a specific Epicor Classic customization, including an example that contains client-side C# code.

Why is this important?

Epicor Kinetic 2026.1 represents a major transition away from the traditional Windows-based Smart Client and Classic UI toward the browser-based Kinetic experience.

If your organization still relies on Classic UI screen customizations, you need a plan for identifying, evaluating, rebuilding, replacing, or retiring those customizations before they prevent you from moving forward with newer Kinetic releases.

This is especially urgent for organizations with years of Epicor customizations that have become deeply embedded in business processes.

What Is the Process for Uplifting Epicor Classic Customizations?

Sam: There are several basic steps organizations should work through:

1. Identify.
Find the Classic UI customizations currently present in your Epicor environment.

2. Prioritize.
Work with the business to determine which customizations are actually important and which ones are still being used.

3. Analyze.
Understand what each customization changes and what business functionality it provides.

4. Uplift.
Convert or rebuild the required functionality using Kinetic tools such as Application Studio and Epicor Functions.

5. Test.
Have business users validate that the new Kinetic experience behaves as expected.

6. Document.
Update both technical documentation and end-user procedures to reflect the new solution.

7. Deploy.
Move the tested and approved functionality into your production environment.

Should Every Epicor Classic Customization Be Converted?

Sam: No.

This shouldn’t be viewed as a purely technical exercise.

The business needs to be involved because the employees using these customizations understand which functionality actually matters.

A customization may exist in the system but no longer be used. Employees may only use one small portion of it. Or newer Epicor functionality may now accomplish the same thing without requiring a customization.

Don’t automatically rebuild everything simply because it’s there.

Use the Kinetic transition as an opportunity to eliminate unnecessary customizations and technical debt.

How Do You Identify Epicor Classic UI Customizations?

Sam: Epicor provides tools that can help identify customizations within your environment.

One useful option in Kinetic is the Configuration Upgrade Dashboard.

Within the dashboard, you can review information about Classic customizations and personalizations currently present in the environment.

Depending on your Epicor version and environment, you may also have access to Epicor upgrade analysis tools that provide additional information about customization complexity and potential uplift requirements.

These tools provide a useful technical starting point, but remember that the inventory still needs business context.

Knowing a customization exists isn’t the same as knowing whether anyone still needs it.

How Do You Determine Whether an Epicor Customization Needs Developer Work?

Sam: Upgrade analysis can help determine whether a Classic customization can be converted relatively cleanly or requires manual developer attention.

For example, a customization may include layout changes, custom controls, fields, buttons, or client-side event handlers.

Cosmetic layout changes may be relatively straightforward to reproduce.

Client-side C# code is different.

If business logic is embedded in an event handler, such as code executed when someone clicks a button, that logic needs to be understood and appropriately recreated for the Kinetic browser experience.

That’s why analyzing the customization before attempting to rebuild it is so important.

What Is an Epicor UI Control?

Sam: A control is essentially an object added to or used on the Epicor screen.

That could be a field, label, button, or another visual element.

If a Classic customization contains multiple custom controls plus client-side code, that gives you an indication of how much work may be involved in recreating the experience in Kinetic.

The number of controls isn’t the only measure of complexity, though. You also need to understand the business logic behind them.

Real-World Example: Uplifting a Custom Epicor Part Entry Screen

Sam: For today’s example, we’re using a real-world Part Entry customization.

The customization contains several changes to the standard Epicor Part Entry experience.

It includes user-defined fields for information such as finish ID and finish color, layout changes that reposition important manufacturing information, and a custom “Next Part” button.

The Next Part button automatically generates the organization’s next available part number.

That’s particularly useful because standard Epicor workflows don’t necessarily determine the organization’s unique part-numbering convention automatically.

The customization stores the next part number in a user-defined field, increments that value, and uses it when the employee creates a new part.

How Do You Compare a Classic Epicor Customization to the Base Form?

Sam: One useful analysis technique is simply opening the standard form and the customized form side by side.

That makes it easier to identify what changed.

Which fields were added? Which fields were moved? Which labels were changed? Which custom buttons exist? What functionality does the customized screen provide that the standard screen doesn’t?

At this stage, we’re trying to separate visual changes from actual business logic.

That’s important because those two categories may require very different uplift strategies.

How Do You Find Client-Side C# Code in Epicor Classic Customizations?

Sam: When working with a Classic UI customization, the Customization Tools dialog gives you access to the script behind the customized form.

The Script Editor can contain the client-side C# code associated with that customization.

In our example, clicking the Next Part button triggers an event handler.

That event handler contains the code responsible for retrieving the next part number, updating the stored value, and putting the new number into the Part Number field.

That logic is important because automatically recreating the visual button doesn’t necessarily recreate the code that runs when someone clicks it.

Can AI Help Analyze Epicor C# Customization Code?

Sam: Yes, and this can be very useful for people who understand Epicor but aren’t necessarily fluent C# developers.

In this example, I copied the event-handler code and asked an AI assistant to explain what the code does.

The AI was able to break the code into plain-English steps, including connecting to the appropriate Epicor service, retrieving a custom value, incrementing the part number, and updating the user interface.

That doesn’t eliminate the need for testing or developer expertise.

But AI can help accelerate the analysis phase by making unfamiliar code easier to understand.

It’s especially useful when you’re dealing with old customizations written years ago by somebody who may no longer work for the organization.

Can AI Write the Replacement Code for an Epicor Customization?

AI can help explain code, suggest modifications, create drafts, and assist developers with translating business logic.

But AI-generated code should always be reviewed, tested, and validated in a non-production Epicor environment before deployment.

The goal isn’t to blindly copy AI-generated code into production.

The goal is to use AI as an assistant that can reduce the time required to understand and recreate existing business logic.

How Do You Automatically Convert Classic Customizations to Kinetic?

Sam: Epicor includes conversion functionality that can help create Kinetic layers from existing Classic UI customizations.

The conversion process can recreate many visual elements from the Classic customization, including custom fields, labels, buttons, and layout changes.

After running the conversion, the resulting Kinetic layer can be reviewed in Application Studio.

In our example, the automated conversion successfully recreated many of the visual components of the customized Part Entry screen.

The user-defined fields appeared. The custom buttons appeared. The repositioned fields appeared.

But one important piece was missing: the client-side event-handler logic behind the Next Part button.

Why Doesn’t Classic C# Code Automatically Convert to Kinetic?

Sam: The Classic Smart Client and the browser-based Kinetic experience use different architectures.

Client-side code that ran inside the traditional Windows-based interface can’t simply be assumed to work in the browser.

That’s why organizations need to separate the business requirement from the original technical implementation.

The business requirement in our example isn’t “run this specific C# event handler.”

The requirement is: automatically generate the next available part number when the user clicks the Next Part button.

Once we understand the requirement that way, we can recreate it using Kinetic-native architecture.

What Are Epicor Functions?

Sam: Epicor Functions provide a way to create reusable server-side business logic.

Instead of relying on client-side code embedded directly inside a particular screen, a function can perform the business logic on the server and then be called from different parts of Epicor.

Functions are reusable, which makes them valuable when the same logic may need to be invoked from multiple workflows.

In our example, we created an Epicor Function that performs the same basic business logic as the original Classic Next Part code.

It retrieves the current next-part value, returns that value, increments it, and updates the stored information for the next request.

How Do You Call an Epicor Function from Application Studio?

Sam: Once the function is created and published, we can return to the Kinetic layer in Application Studio.

The Next Part button already exists because the automated conversion recreated the control.

What we need to add is the behavior.

In Application Studio, we create an on-click event associated with the button.

That event calls the Epicor Function, receives the returned part number, updates the appropriate row and field in the interface, and can also display a notification to the user.

We’ve now recreated the original business functionality using Kinetic-native tools instead of relying on the Classic client-side implementation.

How Do You Test an Uplifted Epicor Kinetic Customization?

Sam: After rebuilding the functionality, test it against the original business requirement.

In our example, we create a new part and click Next Part.

The application calls the server-side function, retrieves the correct value, updates the screen, and allows the user to continue the process.

That validates that the important functionality from the Classic customization has successfully been recreated.

But technical testing isn’t enough.

The business users who rely on the customization should also validate that the new Kinetic experience supports the real-world workflow.

What Is the Best Strategy for Moving Classic Customizations to Kinetic?

A practical approach looks like this:

1. Inventory Classic customizations.
Use available Epicor upgrade tools and your own business knowledge to identify what exists.

2. Talk to the users.
Determine which customizations are still used and which business processes depend on them.

3. Retire what you don’t need.
Don’t spend time recreating obsolete customizations.

4. Analyze what remains.
Separate cosmetic changes, fields, controls, custom business logic, and client-side code.

5. Run Epicor’s conversion tools where appropriate.
Let the platform recreate the compatible portions of the customization.

6. Review the resulting Application Studio layer.
Identify which functionality did and didn’t convert.

7. Rebuild required logic using Kinetic-native tools.
This may include Application Studio events, Epicor Functions, BPMs, or other supported architecture.

8. Test with business users.
Validate that the new solution supports the business process, not just that the screen opens.

9. Update documentation.
Document the technical implementation and revise end-user procedures.

10. Deploy through your normal change-management process.
Move the approved customization into production only after testing and validation are complete.

What Epicor Training Can Help with Kinetic Customization Uplifts?

Sam: If today’s presentation stretched your current Epicor knowledge, there are several areas worth studying.

Learn how Epicor Functions work and how they’re created and maintained.

Spend time getting comfortable with Application Studio, including layers, events, controls, data views, and application behavior.

And if you’re responsible for analyzing old Classic customizations, understanding the embedded Classic customization tools can still be useful during the transition because that’s where you’ll often need to retrieve and understand the existing implementation.

The goal isn’t necessarily to become a full-time developer.

It’s to understand enough of the architecture to determine what you can handle internally and where you need an experienced Epicor developer or partner.

Epicor Classic to Kinetic Customization Uplift: Webinar Q&A

Can Public Cloud and Government Cloud Customers Use Epicor’s ERP Analyzer?

Sam: Availability and the process for running the ERP Analyzer can depend on your Epicor environment and cloud deployment.

If you’re in an Epicor-managed cloud environment and can’t run the tool directly, work with your Epicor account or support contacts to determine the current process for requesting the analysis.

The important thing is obtaining a reliable customization inventory and understanding which items require Kinetic rework.

Why Is There Urgency Around Classic Customizations for On-Premises Epicor Customers?

Sam: On-premises customers may control when they upgrade, but that doesn’t remove the underlying issue.

Moving into Kinetic releases that no longer support the Classic Smart Client means required Classic UI customizations need to be addressed first.

The bigger risk is waiting until the upgrade project is already underway before discovering how much customization work needs to be completed.

Organizations with dozens or hundreds of Classic customizations may need substantial analysis, development, testing, and user validation.

Starting early reduces the chance that customization uplift work becomes the reason your ERP upgrade is delayed.

Can Non-Developers Help with Epicor Classic-to-Kinetic Conversions?

Sam: Absolutely, depending on the complexity.

Business users and Epicor administrators can help identify which customizations are important, document workflows, compare Classic and Kinetic forms, test converted functionality, and validate business requirements.

AI tools can also help explain unfamiliar code in plain English and assist with straightforward code modifications or drafts.

More complex development should still involve somebody who understands the Epicor architecture and can properly test the result.

And always do this work in a development, pilot, or sandbox environment rather than experimenting directly in production.

Can AI Reduce the Cost of an Epicor Kinetic Uplift?

Potentially.

AI can accelerate parts of the analysis process by helping teams understand unfamiliar C# code, identify what a customization is doing, document functionality, and suggest possible implementations.

That may allow internal Epicor administrators or power users to complete more of the inventory, analysis, documentation, and testing themselves and reserve consulting or developer time for the portions that genuinely require specialized expertise.

AI doesn’t eliminate the need for expertise. It can help make that expertise more efficient.

Final Takeaway: Don’t Rebuild Classic Epicor Customizations Blindly

The move from Epicor Classic UI to Kinetic isn’t about recreating every old customization exactly as it existed.

It’s an opportunity to ask a better question:

What business capability does this customization provide, and what’s the best way to deliver that capability in Kinetic?

Sometimes the answer will be Application Studio.

Sometimes it will be an Epicor Function, BPM, standard Kinetic functionality, or another supported approach.

And sometimes the answer will be that the customization isn’t needed anymore.

Inventory first. Prioritize with the business. Analyze the requirement. Uplift only what matters. Test it. Document it. Then deploy it.

Moderator: Thanks, everybody, for joining us today.