Live instruction
Instructor-led sessions explain the process, demonstrate the work, and connect individual topics to the larger operating model.
Instructor-led enterprise training
Advanced ABAP Programming: From Developer To Solution Architect
Build practical, job-relevant capability through live instruction and structured independent practice.
Live sessions6
Instructor time30 hours
Independent practice105 hours
Typical cadenceWeekly · same weekday
Elapsed learning6 weeks
Course overview
Build understanding through guided instruction and serious practice.
Build practical, job-relevant capability through live instruction and structured independent practice.
Who this is for
Practical capability for the work ahead.
An advanced, hands-on bridge for experienced ABAP developers who already know foundational procedural ABAP, ABAP Objects, ABAP SQL, ADT navigation, and basic CDS concepts. Graduates will be prepared for supervised advanced ABAP development, custom-code remediation, quality/performance work, and junior solution-design responsibilities; it is not a substitute for dedicated advanced RAP, SAPUI5, integration, security, or functional-domain architecture training.
How learning works
A weekly cycle built around application.
Live instruction introduces and connects the material. Independent practice turns that material into usable capability.
Independent practice
Expect approximately three to four hours of structured practice for every hour of live instruction.
Trouble-ticket support
Show-stopping practice issues can be documented for instructor review, normally with a response within one to two business days.
Session-by-session curriculum
What you will learn and practice.
Open each session to review the included public topics and the practice expected before the next instructor meeting.
1 Session 1: Architecting Maintainable Modern ABAP5 live hours · 17.5 practice hours
Establish the architectural baseline for evolving procedural or tightly coupled ABAP into cohesive, testable, package-oriented solutions.
Included topics
- Modern ABAP architecture and solution-architect responsibilities
- Object-oriented design: interfaces, composition, dependency inversion, and test seams
- Modern expression-based ABAP and internal-table access patterns
- Clean ABAP, cohesion, package boundaries, and developer documentation
- Refactoring workshop: procedural report to layered OO service
- Architecture decision records and technical trade-off communication
Independent practice
Students create the maintainable code structure and working conventions that every later refactoring, testing, performance, and extension exercise will use.
- Create an ADT package structure for a small business scenario with clear public and internal responsibilities.
- Refactor a procedural report into collaborating classes using interfaces and dependency injection seams.
- Apply modern expression-based ABAP and Clean ABAP naming, method-size, and responsibility rules to improve readability.
- Document architectural decisions, assumptions, and unresolved dependencies in a concise technical design note.
Ready for the next session when: Students can navigate and change their ADT project, explain the responsibility of each class and interface, and bring a refactored solution that is ready to test.
2 Session 2: Engineering Quality Through Tests, Checks, and Debugging5 live hours · 17.5 practice hours
Make quality engineering a normal development workflow by combining ABAP Unit, ATC, debugging, exception design, and review discipline.
Included topics
- ABAP Unit design, test doubles, and behavior-focused test cases
- ABAP Test Cockpit: check variants, findings, baselines, and remediation decisions
- Debugging, dumps, checkpoints, and root-cause analysis
- Exception classes, error contracts, and recoverable failure design
- Authorization checks and secure application behavior
- Code-review workflow and evidence-based technical debt backlog
Independent practice
Students turn their Session 1 solution into code that can be verified, diagnosed, and improved before it reaches integration or transport stages.
- Write ABAP Unit tests for business rules, including positive, negative, and boundary cases.
- Use interfaces or test doubles to isolate dependencies in a unit test.
- Run ATC checks, classify findings by severity and root cause, and correct justified findings without suppressing problems indiscriminately.
- Use the ABAP debugger and exception breakpoints to identify the source of a failing behavior.
- Conduct a structured peer review and submit a short defect-and-remediation log.
Ready for the next session when: Students arrive with a tested and ATC-reviewed codebase, an evidence-based list of unresolved findings, and confidence debugging functional defects.
3 Session 3: Designing for SAP HANA Performance and Scalable Data Access5 live hours · 17.5 practice hours
Enable students to diagnose real performance bottlenecks and redesign ABAP data access using measured evidence rather than folklore.
Included topics
- ABAP SQL, code pushdown, and data-volume-aware query design
- CDS data modeling for reusable read models: associations, projections, and annotations
- Internal-table selection, keys, table expressions, and memory-aware processing
- Performance diagnosis with SAT, ST05 or ADT SQL trace, SQL Monitor, and ATC evidence
- Performance refactoring lab and before-after measurement
- Performance trade-offs: readability, database load, authorization, and operational risk
Independent practice
Students optimize a deliberately inefficient business scenario, validate the improvement with analysis tools, and document the architectural trade-offs.
- Analyze an inefficient program using runtime and SQL analysis tools available in the training system.
- Identify avoidable database round trips, excessive data transfer, and inefficient internal-table processing.
- Refactor ABAP SQL and internal-table code using an evidence-based performance hypothesis.
- Create or improve a CDS-based read model with associations and appropriate annotations where supported by the system.
- Compare before-and-after runtime or trace evidence and record limitations of the optimization.
Ready for the next session when: Students can distinguish a static warning from a measured hotspot, explain an ABAP SQL/CDS design choice, and bring a measured optimization case to Session 4.
4 Session 4: Clean-Core Extension and RAP Architecture5 live hours · 17.5 practice hours
Teach students to select an upgrade-stable extension approach and construct a small modern ABAP service using CDS and RAP building blocks.
Included topics
- Clean-core architecture, ABAP Cloud principles, released APIs, and extensibility decisions
- CDS service-layer design: entities, projections, metadata, and service exposure
- RAP business objects: behavior definitions, managed operations, validations, actions, and service bindings
- API-first integration boundaries, events, and consumer responsibility
- Extension decision workshop: in-app extensibility, developer extensibility, side-by-side, or no custom code
Independent practice
Students apply clean-core decision criteria to a business request, then deliver a working service prototype instead of only discussing modern architecture.
- Classify a requested enhancement by its appropriate extensibility option and justify the decision using clean-core and API considerations.
- Build or extend a CDS data model and expose it through a service definition and binding in the available training environment.
- Implement and test basic RAP behavior such as validation, determination, action, or authorization control.
- Document the service contract, released-object/API dependencies, and extension constraints.
- Identify when a requirement should be escalated to a dedicated RAP, SAPUI5, Integration Suite, or security specialist.
Ready for the next session when: Students can explain the main RAP layers, demonstrate a small service prototype, and make a defensible decision between clean-core extension approaches.
5 Session 5: S/4HANA Custom-Code Adaptation and Delivery Architecture5 live hours · 17.5 practice hours
Prepare students to assess inherited custom code for S/4HANA compatibility, clean-core risk, security, and transportable remediation.
Included topics
- S/4HANA custom-code adaptation: simplifications, readiness analysis, and developer responsibilities
- ATC-based migration assessment, remote checks, finding triage, and remediation workflow
- Remediation patterns: replace obsolete access, use released APIs, isolate legacy dependencies, and preserve behavior
- Authorization, auditability, and data-access risk in custom solutions
- Packages, transports, dependency management, and release-ready delivery evidence
- Custom-code remediation case workshop
Independent practice
Students perform a realistic assessment-to-remediation workflow on custom objects and create an implementation recommendation suitable for a technical lead or solution architect.
- Run or interpret ATC-based custom-code findings relevant to S/4HANA adaptation and classify functional, performance, and clean-core risks.
- Use the Simplification Item Catalog or equivalent system evidence to connect an impacted object to a business and technical change.
- Remediate selected code while preserving tests and recording the rationale for the chosen approach.
- Review authorization behavior, released-API dependencies, package assignment, and transport implications.
- Prepare a concise remediation plan with scope, dependencies, risks, test evidence, and escalation needs.
Ready for the next session when: Students bring a completed remediation packet: analyzed object, corrected code or prototype, test/ATC evidence, performance notes where applicable, and an architect-level recommendation.
6 Session 6: Solution Architecture Capstone and Project Readiness5 live hours · 17.5 practice hours
Demonstrate end-to-end capability by taking a business change from technical assessment through design, implementation, quality evidence, performance review, and stakeholder communication.
Included topics
- Capstone intake: business requirement analysis, nonfunctional requirements, and architectural options
- Capstone build or refactor: implementation clinic
- Quality gate: ABAP Unit, ATC, debugging evidence, and review findings
- Performance and operability review
- Architecture presentation, peer challenge, and project-style handoff
- Portfolio packaging, interview/project-readiness language, and continuing practice plan
Independent practice
Students consolidate all techniques through a realistic delivery simulation and leave with tangible work samples and a prioritized plan for closing remaining skill gaps.
- Analyze a capstone change request and create a lightweight solution design covering boundaries, APIs, data model, extension choice, risks, and acceptance criteria.
- Implement or substantially improve a selected ABAP component in the training system.
- Provide ABAP Unit, ATC, debugging, and performance evidence appropriate to the scenario.
- Present an architecture decision and remediation plan to a mock technical lead, explaining alternatives and trade-offs.
- Repeat weak areas independently after the course using a self-assessment checklist and a structured trouble-ticket format when blocked.
Ready for the next session when: Post-course readiness: students can independently perform an advanced ABAP work item from investigation through implementation and evidence-based handoff, while knowing when to escalate specialized RAP, UI, integration, security, or functional-design work.
Planned start dates
Choose when and how you want to attend.
A start date is listed here only while its enrollment window is still open. The course itself stays in the catalog under its SAP module.
Enroll Now
$2,350.00
Fri, Oct 16, 2026 · 9:00 AM CDT
DeliveryOn-site
LocationLive online
Sessions6
Seats remaining12
View complete schedule
- Fri, Oct 16, 2026 · 9:00 AM CDT
- Fri, Oct 23, 2026 · 9:00 AM CDT
- Fri, Oct 30, 2026 · 9:00 AM CDT
- Fri, Nov 6, 2026 · 9:00 AM CST
- Fri, Nov 13, 2026 · 9:00 AM CST
- Fri, Nov 20, 2026 · 9:00 AM CST
Enrollment protection: sending an enrollment or waitlist request does not reserve a seat and does not constitute payment. Registration becomes final only after Hull Software verifies availability, receives the required payment, and sends the official confirmation email.