Archive for category: News

You are here: / / News

How to Resolve Lawson PR140 Fatal Table error

, ,

Follow this simple guide to learn how to resolve the Lawson PR140 Fatal Table error – See errors files.

A Lawson PR140 (Earnings and Deductions Calculation) fatal table error can mena many things like  the payroll job hit bad data, a lock conflict, or a stuck run flag in your environment files. You may come across this error:

PRDED-DED-TABLE must be increased; Cur size 0500

 

The error occurs when an employee has more than 500 deductions tied to them. This includes all open and closed deductions.

 

To fix this, apply the latest Secure Act 2.0 Patch from Infor since this is addressed in JT-1371703

Alternatively, you could also fix this error via CTP 123335.

AI In ERP Implementation: Accelerating Transformation Without Compromising Strategy

As organizations continue investing in ERP (enterprise resource planning) modernization, AI (artificial intelligence) is becoming a valuable tool for accelerating implementations rather than replacing the people who lead them. In a recent Forbes article by Anand Gupta, Senior Partner at Wipro, it explains how AI is helping organizations reduce manual effort while keeping experienced professionals at the center of decision-making. Traditional ERP implementations are often slowed by repetitive tasks like testing, documentation, training, and issue resolution. According to the article, AI can automate many of these time-consuming activities, allowing IT teams and consultants to spend more time improving business processes and guiding organizational change. Research cited by the author estimates AI can reduce ERP implementation effort by 20% to 40%. One of the biggest opportunities is creating a single workflow for testing and training. Instead of manually rewriting documentation for different audiences, AI can generate regression tests, expected outcomes, user training materials, and multilingual documentation from the same source. This helps organizations deploy updates faster while maintaining consistency across the project. However, Gupta argues that AI is not a substitute for good governance. Successful ERP projects still require experienced leaders to validate AI-generated outputs, oversee process changes, and ensure compliance. Organizations with inconsistent data or poorly defined business processes may need to address those issues before realizing AI’s full benefits. The key takeaway is that AI works best as an accelerator—not a replacement—for ERP strategy. By automating routine tasks while keeping humans in control, organizations can complete implementations more efficiently without sacrificing quality, compliance, or long-term business objectives.

 

For Full Article, Click Here

 

The Hidden Costs of Over-Customizing Your ERP System

As organizations modernize their ERP (enterprise resource planning) environments, finding the right balance between customization and standardization has become a critical decision. In a recent article published by PwC Malta, it explains how excessive ERP customization can create long-term challenges, including higher costs, technical debt, and reduced flexibility. Customization is often viewed as a way to make an ERP system better fit a company’s unique processes. However, while custom features may solve short-term business needs, they can create ongoing maintenance challenges throughout the system’s lifecycle. Each customization requires additional testing, documentation, support, and updates, increasing the total cost of ownership over time. One major risk is upgrade complexity. As ERP platforms evolve and vendors release new features, heavily customized systems become harder and more expensive to update. Organizations may find themselves delaying upgrades because custom code needs to be reviewed, rebuilt, or retested before new functionality can be adopted.

The article also highlights operational risks, including reliance on tribal knowledge. When critical processes depend on custom solutions understood by only a few employees or developers, organizations become more vulnerable when those individuals leave or when business requirements change. Instead of avoiding customization completely, PwC recommends a more disciplined approach: adopt a “fit-to-standard” mindset, prioritize configuration over custom development, and establish governance processes to evaluate whether each customization provides real business value. Organizations should reserve customization for areas that create a true competitive advantage rather than simply recreating existing processes. Ultimately, the goal of ERP modernization is not to create a system that matches every existing habit—it is to create a platform that supports future growth. By keeping the ERP core clean and making intentional customization decisions, businesses can improve agility, reduce costs, and maximize the long-term value of their technology investment.

 

For Full Article, Click Here

Passing Parameters to a Thread Target in Python

, ,

When working with multithreading in Python, a common question is whether you can pass parameters to the function executed by a thread. The short answer is yes — Python’s threading. Thread class provides built-in support for this.

This post walks through the correct and idiomatic ways to pass arguments to a thread target function.

The Basic Thread Pattern

A typical thread is created like this:

import threading

 

t = threading.Thread(target=compare_totals)

t.start()

This works only if compare_totals takes no parameters. If your function requires inputs, you must supply them explicitly.

Passing Positional Arguments with args

Use the args parameter to pass positional arguments to the target function. args must be a tuple.

def compare_totals(source, target):

print(source, target)

 

t = threading.Thread(

target=compare_totals,

args=(“athena”, “oracle”)

)

t.start()

Each element in the tuple maps to a parameter in the function signature.

Passing Keyword Arguments with kwargs

If you prefer named arguments (or want clearer intent), use kwargs:

def compare_totals(source, target):

print(source, target)

 

t = threading.Thread(

target=compare_totals,

kwargs={

“source”: “athena”,

“target”: “oracle”

}

)

t.start()

This approach is especially helpful when a function takes many parameters or optional values.

Passing a Single Object (Such as a Dictionary)

A common pattern is to pass a single dictionary containing multiple configuration values:

def compare_totals(params):

print(params)

 

params = {

“engine”: “mysql”,

“schema”: “public”,

“table”: “employees”

}

 

t = threading.Thread(

target=compare_totals,

args=(params,)

)

t.start()

⚠️ Important:
When passing a single argument via args, you must include a trailing comma: (params,). Without it, Python will not treat the value as a tuple.

Summary

  • Use args for positional arguments
  • Use kwargs for named arguments
  • Always pass args as a tuple, even for a single value
  • Thread targets behave just like normal function calls — the thread simply invokes the function with the supplied parameters

Understanding this pattern makes it much easier to parallelize work cleanly and safely in Python.

 

Hybrid architecture as a permanent enterprise model

As businesses continue modernizing their IT environments, hybrid architecture has become less of a temporary solution and more of a long-term strategy. In an article by AI and tech expert Pam Baker for TechTarget, she explains why organizations are embracing hybrid environments instead of pursuing an all-cloud future. The biggest shift is that companies are no longer asking, “How quickly can we move everything to the cloud?” Instead, they’re deciding which workloads belong on-premises, in the cloud, or across multiple environments based on security, compliance, cost, and performance needs. For industries with strict regulations, a hybrid approach simply makes more sense. The article also highlights that enterprise applications like ERP, CRM, and HR systems often span multiple platforms. As AI-powered automation becomes more common, inconsistent data definitions and disconnected systems create new challenges. Successful hybrid environments require strong governance, standardized data, and clear accountability so AI agents and business workflows can operate reliably across systems. Another key takeaway is that hybrid success isn’t just about infrastructure—it’s about strategy. Organizations should regularly evaluate where applications run, measure business outcomes instead of just uptime, and establish policies that keep costs, security, and performance aligned across environments. Ultimately, hybrid architecture has evolved from a stepping stone to the cloud into the enterprise operating model for many organizations. Businesses that intentionally manage and govern their hybrid environments will be better positioned to adapt as technology, regulations, and AI capabilities continue to evolve.

 

For Full Article, Click Here

Infor Aligns Its Agentic ERP Strategy with ‘Enterprise Resource Execution’ Framework

Enterprise software is entering a new phase where Enterprise Resource Planning (ERP) systems are moving beyond tracking transactions and toward actively helping organizations make decisions and execute processes. In a recent article published by ERP Today, it explores how Infor is positioning Enterprise Resource Execution (ERX) as the next evolution of ERP through the use of agentic AI, industry-specific data, and intelligent automation. Traditional ERP systems have primarily served as systems of record—capturing transactions, managing workflows, and reporting what already happened. ERX introduces a different approach by enabling systems to sense what is happening, analyze context, and help execute actions in real time. Instead of simply showing users information, AI-powered agents can monitor processes, recommend next steps, and eventually perform approved actions across business operations. A major theme in the article is that successful AI agents require more than access to data. They need industry knowledge, reliable data models, governance, and integration across systems. For example, a purchasing AI agent in healthcare may need to consider compliance requirements, while one in manufacturing may prioritize production schedules and supply availability. The value comes from combining AI capabilities with business-specific context. The article also highlights the importance of governance as organizations move toward more autonomous operations. AI agents that influence purchasing, finance, inventory, or supply chain decisions must operate within clear boundaries, with audit trails, approval processes, and human oversight when needed. ERX represents a shift in how organizations think about enterprise systems. The future of ERP may not be defined only by managing resources, but by helping businesses continuously sense changes, make smarter decisions, and execute actions faster. Organizations that build strong data foundations and responsible AI strategies will be better prepared for the move toward the agentic enterprise.

 

For Full Article, Click Here

Updating IdPSigningCertificate for ADFS

, ,

To update the IdPSigningCertificate for Active Directory Federation Services (ADFS) Token Signing Certificate that has been renewed. Follow these steps:

The steps below include the steps to export the Token Signing Certificate from ADFS after it has been renewed.

Export a Signing Certificate from AD FS; The following steps can also be found in the Infor Lawson Authentication Configuration Guide.

  1. Log into the AD FS server and click Administrative Tools->ADFS Management.
  2. On the AD FS window, Click Service to open the Service Snap-in.
  3. Click on Certificates under Service to see the Certificates pane showing all available certificates
  4. Select the certificate under Token-Signing in the Certificates Pane to get to the certificate folder
  5. Click the Copy to File option in the Details tab of the Certificate window
  6. Click Next in the Welcome to the Certificate Export Wizard window
  7. At the prompt, select the “Base64encoded X.509 (.CER)” option to choose the file format in which the certificate is to be exported and then click Next.
  8. At the prompt to select the location where the token signing certificate is to be saved and specify a filename
  9. At the prompt, verify that the file type is “Base 64 Encoded (.cer)” and then click Save.
  10. The Certificate Export Wizard window displays the File Name and location specified. Write down the file path specified or change it to your preferred location.
  11. Click Next to proceed with exporting.
  12. Click Finish. When you see this message, “The export was successful.” Click OK.
  13. Click OK again to close out the wizard.
  14. Locate the file you exported and copy it to the LSF server.

Reload AD FS signing certificate in Lawson System Foundation

  1. Make sure you copied the certificate that was exported in the above steps to a directory on the LSF server.
  2. Run the ssoconfig -c utility from a command prompt.  Enter the password when prompted.
  3. From the main menu, select “Manage WS Federation Settings”.
  4. From the sub-menu, select “Manage Certificates”.
  5. From the next sub-menu, select “Delete IdP certificate”.
  6. At the prompt, type the name of the IdP service, ADFS (this may be different)
  7. Message “Signing Certificate has been deleted successfully” is displayed
  8. From the menu, select “Import IdP certificate”
  9. At the prompt, type the name of the IdP service, ADFS (this may be different)
  10. At the prompt, type the path of the certificate. The system assumes that the certificate is in the current folder so supply path information as needed.
  11. Message “IdP signing certificate has been successfully imported to keystore”
  12. From the menu, select “Exit”

Restart the Lawson System Foundation environment and WebSphere Application server or Cluster in the proper order.

Your ERP Has a Strategy Problem, Not a Payments Problem.

Payments are often viewed as a technology challenge, but the real issue may be much broader. In an article from ERP Today, contributor Ashley Da Silva argues that many organizations focus on payment functionality when the underlying challenge is actually process design, operational efficiency, and ERP (enterprise resource planning) strategy. The article explains that simply adding payment capabilities to an ERP system does not automatically create business value. Many organizations implement payment solutions as bolt-on features that still require users to navigate multiple workflows, reconcile transactions manually, and manage disconnected processes. As a result, businesses see little improvement beyond basic functionality. A key theme is that the real opportunity lies in process efficiency. When payments are fully integrated into ERP workflows, organizations can streamline accounts payable and receivable processes, reduce manual work, improve reconciliation, and gain better visibility into financial operations. The goal is not just to move money faster, but to remove friction across the entire transaction lifecycle. The article also emphasizes that businesses increasingly expect their ERP platform to serve as a unified operational hub. Customers want payments, financial management, and operational processes to work together seamlessly rather than relying on disconnected third-party tools. This creates opportunities for stronger customer retention, improved user experience, and new revenue streams for ERP providers. Ultimately, Da Silva argues that organizations should stop treating payments as a standalone feature and instead view them as part of a broader ERP strategy. Companies that focus on process integration, operational efficiency, and end-to-end workflow design will gain far more value than those that simply add another payment solution to an already fragmented environment.

 

For Full Article, Click Here

Stop blaming your ERP vendor

ERP (enterprise resource planning) failures are often blamed on software vendors, but the real causes usually lie much closer to home. In an opinion piece for CIO by Michele Doverspike, technical program manager with more than 25 years of experience leading enterprise software implementations, she argues that most ERP implementation outcomes are driven by internal decisions around planning, governance, and change management—not by the technology itself.

Drawing on doctoral research involving small businesses that had successfully completed ERP implementations, Doverspike found a surprising pattern: none of the IT leaders interviewed identified the ERP vendor as the primary reason for success or failure. Instead, they consistently pointed to factors within their own control, including preparation, execution, and scope management.

The article highlights three key areas that determine ERP success:

  • Preparation is everything — Successful organizations aligned ERP projects to measurable business goals, secured active executive sponsorship, treated data migration as a priority, and often chose phased rollouts over “big bang” implementations.
  • Execution matters as much as planning — Role-based training, strong governance, effective change management, and minimizing unnecessary customizations were common traits among successful projects. Employees need to understand how the system supports their daily work, not just how the software functions.
  • Scope control is non-negotiable — Small changes and customization requests can quickly derail budgets and timelines. Organizations that maintained strict scope discipline were far more likely to achieve their objectives.

Ultimately, ERP projects are won or lost long before the software is configured. While vendors and external factors certainly play a role, the strongest predictors of success remain leadership engagement, organizational readiness, disciplined execution, and the ability to keep the project focused on its original business goals.

 

For Full Article, Click Here

Why os.getenv() Ignores Your .env File (and How to Fix It)

, ,

If you’ve ever logged an environment variable in Python and thought, “Why is this value coming from my system instead of my .env file?” — you’re not alone.

This is a very common source of confusion when working with AWS credentials, profiles, or configuration-driven applications.

Let’s break down why this happens, how environment variable precedence works, and how to make your .env file behave the way you expect.

The Core Issue: .env Files Are Not Automatic

Calling:

os.getenv(“AWS_PROFILE”)

does not read your .env file by default.

Python only knows about variables that already exist in the process environment. A .env file is just a text file until you explicitly load it.

That’s why libraries like python-dotenv exist.

Loading the .env File Correctly

To load values from a .env file into the environment, you must do this explicitly and early:

from dotenv import load_dotenv

load_dotenv()

After this runs, variables defined in .env become available via os.getenv().

However, this alone does not guarantee your .env values will be used.

Environment Variable Precedence (The Real Gotcha)

Even when load_dotenv() is working correctly, system-level environment variables always take precedence.

If a variable exists in both places:

  1. System environment (PowerShell, shell, OS)
  2. .env file

Python will use the system value, not the .env value.

This is intentional behavior.

Forcing .env to Override System Variables

If you want the .env file to override existing environment variables, you must opt in:

load_dotenv(override=True)

Without override=True, python-dotenv will not replace values that already exist in the environment.

Verifying Where the Value Is Coming From

To debug what’s happening, it helps to inspect both sources:

from dotenv import load_dotenv, dotenv_values

import os

 

load_dotenv(override=False)

 

print(“Value in .env:”, dotenv_values().get(“AWS_PROFILE”))

print(“Value in environment:”, os.getenv(“AWS_PROFILE”))

This makes it immediately clear whether:

  • the .env file was loaded
  • the system environment is overriding it

Common Causes of .env Being Ignored

  1. The variable is already set in your shell

On Windows (PowerShell):

echo $Env:AWS_PROFILE

If this prints a value, it will override .env unless override=True is used.

  1. The .env file isn’t in the working directory

load_dotenv() searches relative to the current working directory. If your script runs from a subfolder, the file may not be found.

You can confirm this with:

import os

print(os.getcwd())

Or specify the file explicitly:

load_dotenv(dotenv_path=”/path/to/.env”, override=True)

  1. The .env syntax is invalid

The .env file must use simple KEY=value syntax.

Correct:

AWS_PROFILE=dev

Incorrect:

AWS_PROFILE = “dev”

  1. .env is loaded too late

Always call load_dotenv() before importing modules that read environment variables.

Key Takeaways

  • getenv() only reads environment variables, not .env files
  • .env files must be explicitly loaded
  • System environment variables override .env by default
  • Use override=True if you want .env to win
  • Always verify where values are coming from when debugging configuration issues

Understanding these rules will save you hours of frustration—especially when working with AWS profiles, credentials, and multi-environment setups.