Chapter 14 · Real-World Skills
Smart Forms & Adobe Forms
How to design and print invoices, purchase orders, and delivery notes — SAP’s two form technologies explained.
Every business document that leaves your company’s SAP system was produced by a form. Invoices, purchase orders, delivery notes, payslips, customer statements, bank confirmations — all of these are forms. If your form prints the wrong amount or the customer’s address, that is not just a bug — it is a business problem.
This chapter teaches you SAP’s two main form technologies: Smart Forms (the classic, still everywhere) and Adobe Forms (the modern, PDF-based successor). You will learn how forms are designed, how they are triggered, and how to debug them when they break.
🎯 What You Will Learn in This Chapter
- What forms are and where they fit in SAP business processes
- The history: SAPscript → Smart Forms → Adobe Forms
- How to design a Smart Form using transaction SMARTFORMS
- How to design an Adobe Form using Adobe LiveCycle Designer
- The role of Print Program and Output Type
- How to trigger print output through NAST and output determination
- How to handle dynamic tables, page breaks, and multi-page forms
- How to troubleshoot printing issues using SP01 and SPAD
📘 What is a Form in SAP?
A form is a formatted business document that SAP generates and prints (or emails, or PDFs). Forms are everywhere in SAP:
- Invoices sent to customers (SD billing)
- Purchase orders sent to vendors (MM purchasing)
- Delivery notes that accompany shipments (SD/LE)
- Payslips for employees (HR/HCM)
- Bank payment confirmations (FI)
- Statements, dunning letters, material documents, remittance advices
Every form combines two things: data (from SAP tables) and design (layout, fonts, logos, tables). The goal is to produce a professional-looking document that meets legal and business requirements.
📜 SAP Forms History — Three Technologies
SAP has three generations of form technology. You will encounter all three in production systems.
| Technology | Era | Design Tool | Status |
|---|---|---|---|
| SAPscript | 1990s | SE71 (text editor with control commands) | Legacy — do not use for new development |
| Smart Forms | 2000s | SMARTFORMS (graphical WYSIWYG) | Still widely used, maintenance mode |
| Adobe Forms | 2010s–present | Adobe LiveCycle Designer + SFP | Modern standard, recommended for new development |
🎨 Smart Forms — The Classic Tool
Smart Forms is SAP’s graphical form designer. It replaced SAPscript and remains the most common form technology in classic SAP systems.
Key concepts of Smart Forms
| Concept | What It Is |
|---|---|
| Form | The complete document definition (invoice, PO, etc.) |
| Style | Reusable set of fonts, paragraph formats, and character formats |
| Pages | Each page of the form (first page, next page, etc.) |
| Windows | Rectangular areas on a page (header, body, footer, address block) |
| Nodes | The content inside a window: Text, Table, Graphic, Address, etc. |
| Table node | Dynamic table with header, data, and footer rows — handles page breaks automatically |
| Program lines | ABAP code embedded in the form for dynamic logic (conditions, loops) |
How to create a Smart Form — Step by Step
Transaction SMARTFORMS. Enter a name like ZSMART_INVOICE and click Create. Choose “Form” as the object type.
Every Smart Form has an Import, Export, Tables, and Exceptions tab. In Import, you define parameters the print program passes (e.g., IV_VBELN for invoice number). In Tables, you define internal tables (e.g., IT_ITEM for invoice line items).
In the Global Settings → Form Attributes, choose a Style (e.g., ZSTYLE_INVOICE). In Form Interface, define your data. In Global Definitions, declare any global variables you need (like GV_TOTAL for the running total).
Right-click on Pages → Create → Page. Name it FIRST. Set Next Page to NEXT. Add windows: HEADER (logo, company name), ADDRESS (customer address), BODY (invoice lines), FOOTER (page number).
Inside each window, right-click and add nodes. Use Text nodes for static text (labels), Program Lines for ABAP logic, and Table nodes for dynamic data (line items).
Inside BODY window, right-click → Create → Table. Define three sections: Header (column titles), Main Area (data rows, loops over IT_ITEM), Footer (totals). Smart Forms automatically handles page breaks — if 100 line items do not fit on one page, it continues on the next page.
Save the form. When you activate, SAP generates a function module automatically (named like /1BCDWB/SF000001). This function module is what your print program calls.
Calling a Smart Form from a Print Program
REPORT z_print_invoice.
DATA: lv_vbeln TYPE vbrk-vbeln.
DATA: lt_items TYPE TABLE OF vbrp.
DATA: ls_control TYPE ssfctrlop.
DATA: ls_output TYPE ssfcompop.
DATA: lv_fm_name TYPE rs38l_fnam.
" 1. Fetch data
SELECT SINGLE vbeln FROM vbrk INTO lv_vbeln WHERE vbeln = '0090000001'.
SELECT * FROM vbrp INTO TABLE lt_items WHERE vbeln = lv_vbeln.
" 2. Set print control options
ls_control-no_dialog = 'X'.
ls_control-preview = 'X'.
ls_output-dest = 'LP01'.
" 3. Get the generated function module name
CALL FUNCTION 'SSF_FUNCTION_MODULE_NAME'
EXPORTING
formname = 'ZSMART_INVOICE'
IMPORTING
fm_name = lv_fm_name.
" 4. Call the Smart Form
CALL FUNCTION lv_fm_name
EXPORTING
control_parameters = ls_control
output_options = ls_output
iv_vbeln = lv_vbeln
TABLES
it_item = lt_items
EXCEPTIONS
formatting_error = 1
internal_error = 2
send_error = 3
user_canceled = 4
OTHERS = 5.
IF sy-subrc <> 0.
MESSAGE 'Error printing invoice' TYPE 'E'.
ENDIF.
📄 Adobe Forms — The Modern Standard
Adobe Forms (officially “Interactive Forms by Adobe”) is SAP’s PDF-based form technology. It is the recommended tool for new form development, especially in S/4HANA.
Key advantages of Adobe Forms over Smart Forms
- True PDF output — smaller file size, better print quality, PDF/A compliance for archives
- Interactive fields — users can fill out PDF forms online (used in ESS, customer portals)
- JavaScript support — calculation logic can run in the PDF itself
- Familiar designer — Adobe LiveCycle Designer looks like InDesign / Illustrator, easier for designers
- Barcodes and QR codes — natively supported
- Better performance — faster processing for high-volume printing
Adobe Forms architecture
| Component | Purpose |
|---|---|
| Interface | Defines what data is passed in (similar to Smart Forms Import) |
| Form (Layout) | The visual design — created in Adobe LiveCycle Designer |
| Context | Maps interface data to layout fields |
| Driver Program | ABAP program that fetches data and calls the form |
Creating an Adobe Form — Key Steps
Transaction SFP. Create an Interface object. Define import parameters and internal tables (just like Smart Forms). Add a code section for any ABAP logic that runs before the form is rendered.
Create a Form object. Attach the interface you just created. Click the Layout tab to launch Adobe LiveCycle Designer.
In Adobe LiveCycle Designer, drag and drop text fields, tables, images, and barcodes. Bind fields to the data context. Set fonts, colors, and print sizing.
Save the layout back to SAP. Activate the interface and form. SAP generates a function module (like Smart Forms) that you call from your driver program.
Calling an Adobe Form
DATA: lv_fm_name TYPE rs38l_fnam.
DATA: ls_output_params TYPE sfpoutputparams.
DATA: ls_docparams TYPE sfpdocparams.
" 1. Get function module name
CALL FUNCTION 'FP_FUNCTION_MODULE_NAME'
EXPORTING
i_name = 'ZADOBE_INVOICE'
IMPORTING
e_funcname = lv_fm_name.
" 2. Set output parameters
ls_output_params-preview = abap_true.
" 3. Call the form
CALL FUNCTION lv_fm_name
EXPORTING
/1bcdwb/docparams = ls_docparams
iv_vbeln = lv_vbeln
TABLES
it_items = lt_items
EXCEPTIONS
usage_error = 1
system_error = 2
OTHERS = 3.
⚙️ Triggering Output — Output Types & NAST
Forms do not print by themselves. Something must trigger the output. This is done through output determination, which combines a print program, a form, and a trigger condition.
The classic output pipeline
| Component | What It Does |
|---|---|
| Output Type | The name of the trigger (e.g., RD00 for invoice print, NEU for PO print) |
| Print Program | The ABAP report that fetches data and calls the form |
| Form | The Smart Form or Adobe Form to render |
| NAST Table | Classic output table storing pending outputs (in S/4HANA, replaced by BRF+) |
| Output Determination | Configuration that decides which output type to trigger for which document |
How it works — the flow
- User creates a business document (e.g., saves an invoice)
- The application calls the output determination logic
- Based on configuration, an output type is selected
- An entry is created in the NAST table (or equivalent)
- The print program runs and calls the form
- A spool request is created with the output
- The spool is sent to the printer (immediately, scheduled, or manually)
- RD00 — Invoice print (SD)
- NEU — Purchase order print (MM)
- LD00 — Delivery note (SD/LE)
- ZP01 — Payment advice (FI)
🔧 Troubleshooting Forms — SP01 and SPAD
When a form does not print (or prints wrong), you debug it with two transactions.
| Transaction | Purpose |
|---|---|
| SP01 | Spool Output Controller — view print requests, reprint, delete, check status |
| SPAD | Spool Administration — configure printers, check spool devices, manage output devices |
| SU01 | Check if the user has print authorization |
| SM37 | Check background jobs that trigger print programs |
Common form problems and fixes
| Problem | Cause | Fix |
|---|---|---|
| Form does not print | Wrong output type or print program | Check NAST entry, verify output type config |
| Data missing on form | Print program did not fetch all data | Debug print program, check SELECT logic |
| Page break at wrong place | Table row height or window size | Adjust window/table settings in form designer |
| Wrong print format (A4 vs Letter) | Form page format mismatched | Set correct page format in form attributes |
| Printer offline | Hardware issue | Check printer status in SPAD, contact IT |
| Output sent but never prints | Printer queue stuck | Check SP01 spool status, restart device |
⚖️ Smart Forms vs Adobe Forms vs SAPscript
| Feature | SAPscript | Smart Forms | Adobe Forms |
|---|---|---|---|
| Design tool | SE71 (text editor) | SMARTFORMS (graphical) | SFP + Adobe LiveCycle |
| Output format | SAP proprietary | SAP proprietary (PDF-capable) | True PDF |
| Dynamic tables | Manual code | Automatic | Automatic |
| Interactive fields | No | No | Yes |
| Barcodes/QR | Limited | Yes | Yes (advanced) |
| S/4HANA support | Deprecated | Supported (maintenance) | Recommended |
| Migration urgency | High | Medium | None |
📝 Chapter Summary
- Forms are formatted business documents generated by SAP — invoices, POs, delivery notes, payslips.
- SAPscript — legacy text-based forms. Do not use for new development.
- Smart Forms — graphical designer (SMARTFORMS). Still common in production. Supports dynamic tables, images, barcodes.
- Adobe Forms — PDF-based, modern standard (SFP + Adobe LiveCycle Designer). Supports interactive fields, JavaScript, and true PDF output.
- Print Program — ABAP report that fetches data and calls the form. Kept separate from the form itself.
- Output Type + NAST — configuration that triggers which form to print for which business document.
- SP01 — view spool requests. Every print job lives here. Look here first when a form does not print.
- SPAD — printer configuration and output device administration.
🎤 Interview Questions & Answers
Forms are a common interview topic — especially “Smart Forms vs Adobe Forms” and “how does printing work in SAP”. Know these cold.
A Smart Form is SAP’s graphical tool for designing and printing business documents like invoices, purchase orders, delivery notes, and payslips. It replaced the older SAPscript technology. Smart Forms use a graphical form painter, are stored as function modules, and support dynamic tables, images, barcodes, and multi-page layouts with page breaks.
SAPscript is SAP’s older form technology based on text editors and control commands. Smart Forms is the modern replacement with a graphical WYSIWYG designer. Smart Forms are easier to design, generate a function module automatically for printing, and support better table handling. SAPscript is still found in older systems but not recommended for new development.
Adobe Forms (also called Interactive Forms by Adobe) is SAP’s PDF-based form technology. It uses Adobe LiveCycle Designer to design forms and generates PDF output. Adobe Forms are used for both print output and interactive scenarios (like online forms with input fields), and are the recommended approach for new SAP form development.
Smart Forms use SAP’s own form designer and output in SAP’s classic format. Adobe Forms use Adobe LiveCycle Designer and output true PDF, supporting interactive fields, JavaScript logic, and modern PDF features. Smart Forms are legacy but still widely used; Adobe Forms are the recommended approach for new development, especially in S/4HANA.
Print output is triggered by a combination of a print program and an output type. The print program is an ABAP report that fetches data and calls the form. The output type defines when and how the form is printed. Output determination (via NAST table in classic systems or BRF+ in S/4HANA) decides which output type to trigger. Forms are printed via SP01 (output controller) or automatically by the application.
A print program is an ABAP report that retrieves data from the database, calls the associated Smart Form or Adobe Form, and passes data to it. It also defines the print parameters (printer, number of copies) and handles the output. Every form has an associated print program.
SP01 is the Spool Output Controller transaction. It displays spool requests — every print job in the system creates a spool request. You can view, reprint, delete, or check the status of output requests here. Print errors (like printer offline or missing forms) can be diagnosed in SP01.
In Smart Forms, dynamic tables are created using the Table node type. You define the table structure with header rows, data rows, and optional footer rows. The form automatically calculates how many rows fit on each page and handles page breaks. This is much easier than in SAPscript, where you had to code the page-break logic manually.
🛠 Practice Task for This Chapter
Build your first Smart Form and print it. This is the single best way to internalize how forms work.
- Create the Smart Form: Transaction SMARTFORMS. Name it
ZSMART_DEMO. Add an Import parameterIV_NAME(type string) and a Table parameterIT_ITEMS. - Design Page 1: Create a page with two windows — a HEADER window with static text “My First Form” and a BODY window with a Text node that outputs
IV_NAMEusing a program line. - Add a Table: Inside BODY, add a Table node. Define a header row (e.g., “Item | Description”) and a Main Area that loops over IT_ITEMS.
- Save and Activate. Note the generated function module name.
- Write the Print Program: Create
Z_PRINT_DEMO. CallSSF_FUNCTION_MODULE_NAMEto get the FM, then call the FM withIV_NAME = 'Your Name'and 5 test items in IT_ITEMS. - Print/Preview: Run the print program. It should display a preview of the form with your name and the 5 items.
- Check SP01: Open SP01 and find your spool request. Verify the output.
Test: Kon Banega Crorepati?
5 questions. ₹1 Crore. Prove you understood Smart Forms & Adobe Forms. No pressure — restart anytime.
Explore Our Instructor-Led SAP & IT Courses
Self-study works. But if you want guided training, real project practice, and placement support — here are the courses we offer. Book a free demo before you decide.
WhatsApp us