On HANA Already but Reports Still Slow? What a Migration Does Not Fix

SAP Performance Optimization

The platform changed but the custom code did not. That single fact explains why so many teams finish a SAP ECC to S4HANA Migration, celebrate the cutover, and then watch the same report crawl on Monday morning. The database got faster. The ABAP sitting on top of it still behaves as if nothing happened. SAP Performance Optimization starts with that gap, and 2iSolutions sees it on nearly every post-migration engagement in Canada.

Why Do Reports Stay Slow After Moving to HANA?

Reports stay slow because a HANA migration moves the platform, not the code. Custom ABAP written for a row-store database keeps its old habits: loops that hit the database repeatedly, wide table reads, and heavy calculation in the application layer. HANA runs that code faster, but it cannot rewrite the logic.

Think about a custom open-items report built in 2012. It reads a few hundred thousand rows into an internal table, loops through them, and calls the database again for each customer. On the old database, a tuned index hid some of the pain. On HANA, the same pattern still wastes round trips between the application server and the database.

Many project plans treat the migration as the finish line. Budget goes to conversion, testing, and cutover. Nothing is left for the code that users feel every day. So the business hears “we’re on HANA now” and expects speed, while the slowest transactions stay untouched.

What the migration really changes

A migration changes the database engine, the data model in some areas, and the hardware profile. It does not change your Z programs, your user exits, or your custom enhancements. Those objects carry the original design decisions forward, good and bad.

The practical takeaway is simple. Treat the move as the start of tuning, not the end of it. The teams that do this well schedule a dedicated tuning window right after go-live, with named owners for each slow program and a shared list of targets. Without that structure, performance complaints get logged as general support tickets and quietly age in a queue.

Why testing hides the problem

Most migration test cycles use a trimmed copy of production data. A report that reads 50,000 rows looks fine in that environment. Production holds a decade of history, so the same report reads far more and stalls. Teams then blame the new platform when the cause is code that never faced real volume.

The remedy is to test the heaviest reports against a full-size copy before cutover, or at least a representative sample that keeps the same data skew. Skew matters because one customer with two million postings can slow a report far more than the average customer ever would.

How Do Row-Store and Column-Store Databases Differ?

A row-store database keeps all fields of a record together on disk, while a column-store database keeps each column together. Row stores favour reading or writing one full record. Column stores favour scanning and aggregating a few columns across millions of rows, which is what most reporting does.

That difference drives every tuning decision on HANA. A column store compresses well and scans fast, so asking the database to add up one amount column across a large table is cheap. Pulling every column of every row into ABAP and adding them there is not.

For example, a sales report that totals revenue by region should send that question to the database and get back a handful of rows. Many legacy reports instead fetch every line item and sum it in a loop. The column store sits idle while the application server does the work.

Compression also changes the economics of memory. Because similar values sit next to each other in a column, HANA can store large tables in far less space than a row store needs. That is one reason the platform keeps data in memory at all. It also means that wide reads, which touch many columns at once, lose much of that advantage and pull more data than the question requires.

Where row-store thinking still hurts

Old habits tend to show up in a few places:

  • Selecting all fields with SELECT  when the report needs four columns.
  • Reading a table row by row inside a loop instead of in one call.
  • Sorting and summing in ABAP instead of asking the database.
  • Copying large tables into internal tables before filtering them.

None of these crash anything. They simply waste the strength of the new engine.

Which Anti-Patterns Slow Down Custom Code?

Three anti-patterns cause most post-migration slowness: database calls inside loops, full-table scans, and aggregation in ABAP instead of the database. Each one is easy to write, easy to miss in testing with small data, and expensive in production with years of history.

A database call inside a loop is the classic. A developer reads a header table, then for each header reads the matching items one at a time. With 50 test records it feels instant. With millions of production records, the round trips add up to minutes.

Full-table scans come next. A query without a useful filter forces the database to read the whole table. On a column store that runs faster than on a row store, but it still burns memory and CPU when ten users run it at once.

Aggregation in ABAP is the third. Totals, counts, and grouping belong in the database, where the column store handles them in a single pass. Moving that work down is often the biggest single gain.

A fourth habit deserves a mention even though it is less common: repeated identical reads. Some programs fetch the same customer or material master record dozens of times in one run. Buffering the result in an internal table after the first read removes those calls without any redesign, and it is one of the cheapest wins available.

The fix, in plain terms

Developers can push work to the database through code pushdown. Code pushdown means moving calculation logic from the ABAP layer into the database layer so the data never travels. Open SQL joins, aggregate functions, and Core Data Services views all support it.

A good rule of thumb helps here. If the program only needs a total, a count, or a filtered subset, the database should produce it. If the program needs complex business rules that cannot be expressed in SQL, keep that logic in ABAP but feed it the smallest possible dataset.

How Do You Find the Slowest Programs First?

You find the slowest programs by measuring real usage, not by guessing. Start with runtime statistics from production, rank transactions by total time consumed, and trace the top offenders. A short list of heavy hitters usually explains most of the user complaints.

Here is a practical sequence that works on most systems:

  1. Pull workload statistics for the last three months and rank programs by total database time.
  2. Ask business users which reports they dread, then compare their list to the data.
  3. Run a code inspection on the top custom programs to flag known anti-patterns.
  4. Trace the worst five with the SQL trace and runtime analysis tools.
  5. Fix the highest-impact item first, retest with production-sized data, and repeat.

Step two matters more than people expect. A report that runs once a month for 20 minutes may never appear in the statistics, yet the finance director remembers it every close. Numbers tell you what costs the most. Users tell you what hurts the most. For the tracing step itself, SAP’s guide to troubleshooting HANA performance issues walks through the diagnostic tools in detail.

Keep a simple record as you go. For each program, note the runtime before the change, the change itself, and the runtime after. That record proves the value of the work to sponsors, and it gives the next developer a template for similar problems.

Match the fix to the cost

Not every slow program deserves a rewrite. Some need an index or a smaller field list, and those fixes take an afternoon. Others need a full redesign using CDS views. Rank each candidate by effort and payoff before you commit developer time.

A simple two-by-two grid works well for this. Programs that are slow and used daily with a cheap fix go first. Programs that are slow but rarely used, and expensive to fix, go to the bottom of the list or get retired. Many teams discover that a fair share of their custom reports are no longer used at all, and removing them is the fastest tuning step of all.

Can the User Interface Make Performance Worse?

Yes, the user interface can add delay even when the database responds quickly. Heavy screens, oversized result lists, and chatty calls between the front end and the back end all slow the experience. Tuning the database while ignoring the screen leaves users unhappy.

SAP Fiori is the browser-based user experience layer for SAP applications. Many teams adopt it during or after migration, and it changes how performance is felt. A Fiori app that loads 10,000 rows into a table on the first screen will feel slow no matter how fast HANA runs. Paging, filtering by default, and requesting only the fields on screen fix most of these cases.

Network distance matters too. A plant in Alberta reaching a data centre in Ontario adds latency to every call. Apps that make many small requests suffer more than apps that make a few well-shaped ones. Developers should check how many calls a single screen makes before blaming the server.

Browser behaviour plays a part as well. Large payloads, unoptimised images, and heavy scripts all add seconds before a user sees anything useful. Measuring the load time from the user’s desk, rather than from the data centre, often reveals delays that server-side monitoring never shows. A quick test from a remote site with a typical laptop is worth more than another round of database tuning.

What Role Do Migration Planning and Outside Help Play?

Good planning builds tuning into the migration itself instead of treating it as cleanup afterward. Teams that reserve time for custom code review before cutover avoid the Monday morning surprise. Outside specialists help because they have seen the same patterns across many systems.

A well-run SAP ECC to S4HANA Migration includes a custom code analysis early in the project. That analysis flags objects that will break and objects that will merely run slowly. Fixing both in the same window costs far less than returning later with a separate project and a new budget request.

For companies without deep ABAP capacity, SAP Consulting Services Canada can fill the gap with developers who know HANA-specific tuning. That matters in a tight market, where experienced ABAP and HANA specialists are hard to hire full-time. A short, focused engagement often delivers more than a long hiring search.

Timing deserves attention too. The best moment to start tuning is during the final test cycles, when the code is stable but the project still has budget and momentum. Once the team disbands and the sponsors move on to the next initiative, performance work competes with every other request for attention, and it usually loses.

If you are a consultant reading this, the opportunity is clear. Developers who can read a trace, spot a loop-bound query, and rewrite it with pushdown are in steady demand. That skill set separates a routine ABAP resume from one that employers fight over.

Questions to ask before you hire help

  • Does the team have recent HANA tuning experience, not only migration experience?
  • Can they show how they measure results before and after a fix?
  • Will they train your own developers so the gains last?

Frequently Asked Questions

Q. Why is my SAP system still slow after migrating to HANA?

A. The migration changes the database but leaves custom ABAP code untouched. Programs with database calls in loops or heavy ABAP calculation keep their old behaviour. Tuning that code is what delivers the speed users expect.

Q. What is code pushdown in SAP HANA?

A. Code pushdown moves calculation work from the ABAP application layer into the database. The database aggregates and filters data in one pass, and only the result travels back. This approach usually gives the largest gains on reporting programs.

Q. How long does post-migration tuning take?

A. A focused review of the top custom programs often takes a few weeks, depending on how many objects need changes. Quick fixes such as smaller field lists land in days. Larger redesigns take longer and should follow a ranked priority list.

Q. Does SAP Fiori slow down a HANA system?

A. Fiori itself does not slow the system, but poorly designed apps can. Screens that load too much data or make many small calls feel sluggish. Careful paging and filtering keep them quick.

Q. How can 2iSolutions help with slow SAP reports?

A. 2iSolutions provides ABAP and HANA specialists who review custom code, trace the slowest programs, and fix them. We also place consultants for short or long engagements across Canada.

Where Tuning Fits After the Cutover

A HANA migration gives you a faster engine, but your own code decides how much of that speed users feel. Slow reports usually trace back to a handful of programs with loops, scans, and ABAP-side totals. Find them with real usage data, fix the biggest first, and test with production-sized volumes.

The same thinking applies to the screen layer and to project planning. Fiori apps need sensible paging, and migration budgets need a line for custom code review. Teams that plan for both avoid the long tail of complaints that follows many go-lives.

Email us at info@2isolutions.com to request a performance review