SE24 versus SE37: Find the class or function module without guessing its contract
A manufacturer's custom order-review application names a class method or function module in its failure chain.
START HERE · NO PRIOR TOPIC KNOWLEDGE NEEDED
What it is. Why it matters.
A class groups related data and methods; a function module is a callable procedure. SE24 is the classic Class Builder, while SE37 is Function Builder, so the object type determines where to look.
Completely new to SAP?
Manufacturers use SAP to connect work such as buying components, recording inventory, planning production, shipping equipment and accounting for costs. SAP S/4HANA is an enterprise resource planning system: it connects these activities through shared business data.
ABAP is SAP’s programming language for business applications. A program reads data, applies rules and produces a result. Start with the objects involved before investigating code.
A transaction code, or t-code, is a shortcut to a task in classic SAP GUI. Fiori apps provide another way to work. Names and screens depend on the product and release; you do not need a live system to learn the concepts in this guide.

Scope and source-review notes
Scope and evidence
Source review by FAST SAP SOLUTIONS® editorial. This badge describes our editorial review; it does not represent SAP certification or independent endorsement.
Classic Class Builder and Function Builder object discovery; test facilities and supported consumption depend on backend release and language version.
Primary documentation reviewed on 14 November 2026 using official indexed excerpts. Documentation review only; authored examples were not compiled or executed in an SAP system.
A MANUFACTURING EXAMPLE
Trace a rejected manufacturing order check
Which object are you inspecting?
Read the example values
- Named object
- ZCL_ORDER_REVIEW
- Object type
- Global class
- Classic display tool
- SE24
- Function module tool
- SE37
A REAL SCREEN TO RECOGNIZE

SE37 Function Builder in SAP’s RFC tutorial. The Attributes tab identifies the module and processing type; the parameter tabs describe a different part of its contract.
© 2024 SAP SE or an SAP affiliate company. All rights reserved. Reproduced unchanged for educational commentary. This is a source example, not a capture of your system.Words you’ll meet in this guide
- Program
- A set of instructions executed by a computer.
- Class
- A reusable unit that groups data with operations called methods.
- Database
- Organized information kept beyond one program execution.
- Internal table
- A list of rows held temporarily in an ABAP program’s memory.
- Key
- One or more fields used to identify or find a record.
- ABAP
- SAP’s programming language for business applications.
- API
- A defined interface through which programs exchange data or request actions.
- BAPI
- Business Application Programming Interface: an SAP interface for a business operation.
- ADT
- ABAP Development Tools: SAP tools for ABAP development in Eclipse and, on supported systems, Visual Studio Code.
Preview the practical steps
SEE THE CONNECTION
See it in a simple example.
A small example to make the idea concrete.
Trace a rejected manufacturing order check
A manufacturer's custom order-review application names a class method or function module in its failure chain.
Choose SE24 for a global class and SE37 for a function module
An error naming a class method belongs to a different repository object from a function module.
Scope and prerequisites
This guide covers classic ABAP Workbench inspection with SE24 and SE37, plus the same reasoning when using ADT navigation.
Read the name as an object identity
Suppose the incident names ZCL_ORDER_REVIEW=>CHECK.
Trace a rejected manufacturing order check
A manufacturer's custom order-review application names a class method or function module in its failure chain.
Inspect the exact object, caller and interface contract before executing an unfamiliar business operation to investigate the rejection.
| Reader | Business question | Evidence to carry forward |
|---|---|---|
| SAP developers and application teams supporting manufacturers | Trace a rejected manufacturing order check | Inspect the exact object, caller and interface contract before executing an unfamiliar business operation to investigate the rejection. |
01 Choose SE24 for a global class and SE37 for a function module
An error naming a class method belongs to a different repository object from a function module. SE24 is the classic Class Builder for global classes and interfaces; SE37 is Function Builder for function modules. Start with the exact object identity and affected system, then inspect its interface before deciding whether to execute or reuse it. [1] [2]
Finding an object is only discovery. A visible function module may update documents, depend on caller-managed transactions or be an internal implementation detail. A public method can have equally important preconditions. This tutorial follows a fictional order-review failure from an object name to its contract, caller and a controlled verification plan.
02 Scope and prerequisites
This guide covers classic ABAP Workbench inspection with SE24 and SE37, plus the same reasoning when using ADT navigation. Available test environments, source editors and object metadata vary by backend release. In ABAP Cloud, released-interface and language-version checks are an additional requirement; opening a classic tool does not establish permitted consumption.
You need authorized source/interface display access and the ability to inspect the relevant application caller. Keep the affected system/client, source revision and error message available. You do not need to execute an unfamiliar posting function to understand its parameters. Runtime verification, when needed, should use an approved development fixture and the documented operation contract.
03 Read the name as an object identity
Suppose the incident names ZCL_ORDER_REVIEW=>CHECK. The class is ZCL_ORDER_REVIEW and CHECK is a component. Open that class and method, retaining whether it is static or instance-based and which interface declares it. Searching SE37 for a similar CHECK_ORDER name can lead to an entirely unrelated object. [2]
If the incident instead names function module Z_ORDER_CHECK, inspect it in Function Builder and identify its function group, package and documentation. The containing function group matters because global state and related functions can affect behavior. A local class inside a report is another case: inspect its owning program rather than expecting a separately addressable global Class Builder object. [2]
04 Worked case: an order check rejects customer C200
Fictional report Z_ORDER_UPLOAD calls ZCL_ORDER_REVIEW to validate order O100 for customer C200. The class delegates a legacy validation to function module Z_ORDER_CHECK. The UI displays only “Order rejected.” A useful investigation needs to determine which contract produced the rejection and whether the caller interpreted it correctly.
Use a three-object chain: report, class method and function module. Record the input values at each boundary. A class can convert or default parameters before calling the module, and the report can turn returned warnings into errors. Testing the function module alone with different inputs would therefore not reproduce the actual application path.
| Object | Boundary question | Evidence |
|---|---|---|
| Z_ORDER_UPLOAD | Which order/customer does the user request? | Typed input and active caller |
| ZCL_ORDER_REVIEW=>CHECK | How are inputs and errors translated? | Method signature and implementation |
| Z_ORDER_CHECK | What does the legacy validation return? | Function interface, documentation and result |
| UI message mapping | Why does the user see rejection? | Caller severity and outcome handling |
05 Inspect a class contract beyond its method name
In the class definition, inspect visibility, interfaces, inheritance and the method signature. An instance method may require construction or a factory to establish valid object state. A static method has a different invocation model but can still depend on application context. Read importing, exporting, changing and returning parameters together with declared class-based exceptions.
Check parameter types and meaning. A four-character company code and a customer number may look like ordinary text while carrying conversion and domain semantics. Avoid supplying a display-format value where the interface expects an internal key. If a superclass or interface owns the contract, inspect it before treating an implementation detail as the public API.
06 Inspect the function-module contract and processing context
In Function Builder, inspect the complete parameter interface, documented exceptions and any RETURN structure/table. Determine whether the module is designed for ordinary local use, remote enablement or a special processing context in the installed system. A remote-enabled flag alone is not proof of a released external business API. [1]
Read the function documentation and actual caller for transaction ownership. Some operations collect changes for a later commit; others require surrounding initialization or locking logic. A standalone test can miss those preconditions. SAP's Function Builder support guidance also distinguishes the development tool from application logic owned by the function's application component, so route a business defect with its owning object evidence.
07 Compare typed values at each boundary
For O100, record the internal customer key passed by the report, any normalization in CHECK and the final parameter supplied to Z_ORDER_CHECK. Compare company code, date and process mode as well as customer identity. A valid customer in one company or date context does not necessarily satisfy another validation.
Then inspect results without reducing them prematurely to one text. If the function returns multiple messages, retain their type, identifier and sequence through the class mapping. If it raises a declared exception, follow the matching handler. If the method supplies an explicit rejection flag, check that the caller does not invert its meaning or reuse a previous result.
Read the caller first
Locate the actual invocation and the values constructed for it.
Expected observation: The test inputs match the failing application.
Inspect public interfaces
Record required parameters, types, outputs and exceptions.
Expected observation: The operation contract is visible.
Follow transformations
Trace defaulting, conversion and severity mapping across wrappers.
Expected observation: A changed meaning has an identifiable boundary.
Locate ownership
Record package, application context and relevant supported-use metadata.
Expected observation: The repair is directed to the responsible component.
08 A test button is a real execution boundary
Before a tool test, establish whether the operation can create or change business data, acquire locks, schedule updates or call another system. Use disposable data in an authorized non-production environment when a write-capable test is justified. Preserve the actual transaction contract rather than adding an arbitrary commit because a result looks incomplete.
For the illustrative order checker, prefer a read-only or explicitly validation-only path only if the object documents one. A parameter called TEST does not establish its behavior without documentation. If standalone invocation cannot reproduce required state, test through a small caller or the supported application path instead of concluding the module works merely because one isolated call returned normally.
09 Troubleshooting object-discovery mistakes
Keep discovery, contract interpretation and runtime behavior separate. The right object can still be called incorrectly, and a correct isolated result can still be mapped incorrectly by its caller.
| Observation | Question | Next useful evidence |
|---|---|---|
| Class name not found in SE37 | Is it a class rather than a function? | Open exact class in SE24/ADT |
| Function succeeds alone; app rejects | Are inputs/context identical? | Compare actual caller parameters |
| No exception; business operation failed | Does RETURN carry an error? | Read all documented result messages |
| Instance method cannot be tested directly | How is valid state constructed? | Constructor/factory and caller lifecycle |
| Similar object found in another package | Is it the same implementation? | Package, system and active version |
| Object visible; Cloud reference rejected | Is the required API contract released? | API State and language-version visibility |
10 Verify the hypothesis through a small fixture
Use a positive case for a valid order/customer/context combination and a negative case for a deliberately missing or disallowed customer. Verify the method's declared outcome and the report's user-visible result separately. In both cases, compare the exact values reaching the legacy module with the intended fixture.
Add a boundary case with an initial optional parameter and one with a required parameter missing. If the class defaults a date, make that default explicit in the expected result. Test a valid call followed by an invalid call to reveal stale output or messages. These checks are proposals until executed; do not describe a documentation-based object inspection as a reproduced fix.
11 A concise contract worksheet for implementation review
Write the resulting interface description in business terms: “CHECK validates one order/customer pair for a company and date, returns a rejection outcome with messages, and performs no posting under the documented validation contract.” Only make the last claim after checking the actual object; this is an illustrative worksheet rather than a statement about any SAP-delivered function.
For new development, add the release-contract evidence and a supported alternative if the discovered object is internal. For maintenance, preserve the wrapper's public exception and message behavior while fixing the actual cause. Avoid modifying a shared standard object simply because it was the first location opened from a dump. Discovery should narrow ownership, not expand the change scope.
12 Frequently asked questions
Can SE24 open local classes? Local classes belong to their owning program or class pool; inspect that source context. SE24 primarily addresses global repository classes and interfaces.
Can I treat every BAPI or remote-enabled function as interchangeable? No. Read the specific business and transaction contract, result messages and supported API status.
Why does the function return normally when the business action failed? Some interfaces report business errors through RETURN rather than a raised language exception. The caller must inspect the documented result channel.
What should I hand over? Provide exact object identity, system/version, caller chain, sanitized inputs, result contract, failing transformation and proposed checks. Another developer should be able to understand the failure without guessing which of several similarly named objects you tested.
Related services and next steps
Primary sources
Found this useful?
Share this guide with your network, or leave a like.
Your like is saved in this browser.