The document discusses the steps for being an efficient SAP ABAP programmer or technical team lead. It outlines 10 key steps: 1) Review business requirements and write a functional specification, 2) Review ABAP development standards, 3) Write and review test cases, 4) Write and review technical design specifications, 5) Realize the specification through ABAP development, 6) Follow SAP development best practices, 7) Conduct ABAP code reviews and perform testing, 8) Create documentation, 9) Conduct user acceptance testing, and 10) Migrate the code to test and production systems. The overall process moves from requirements gathering to development to testing to deployment.

1. Successful & Resourceful SAP ABAP Developer
I have the privilege of being a ABAP developer for past 9 years and IT industry as a programmer
for 12 years and now being a ABAP technical expert and development manager for 12 SAP
implementations, I have come across different working patterns of a professional ABAP
developer. During this time I have met a few ABAP programmers that were very good with
technical aspects and also some that were excellent ABAP development consultants who could
manage every aspect of a SAP development project whether undertaking a custom development,
BADI implementations or enhancement project. Remember that as a technical SAP expert you
are the critical piece of a project responsible for realizing the vision of SAP customer business
processes into production. I think it is very important to know a lot of different programming
aspects during an SAP implementation project and follow certain guidelines that can make an
SAP ABAP professional very successful in your career.
Steps for being an Efficient SAP ABAP Programmer or SAP Technical Team Lead
1. Review Business Requirements & Write Functional Specification
The first part of any ABAP development project begin with meeting the end users or business
experts and understand the business requirements that need to be implemented in the SAP system
during the realization phase. A best approach is to conduct workshops to gather all the business
requirements. Make sure that if any SAP function consultants are involved than they are in the
meetings as well. After all the business requirements are collected, either a SAP functional
consultant or business expert will write a detailed functional specification. Review the functional
specification until the document has all the details, different business scenarios and expected
goals clearly defined. A well defined functional specification should contain UML diagrams and
test case scenarios. It is important to have an official signoff on the functional specification
before continuing with design and development.
2. Review ABAP Development Standards
In ideal case, your SAP Project Lead or ABAP Development Manager should have created a
programming standards and guidelines document. Review this document so that you follow the
naming conventions for function modules, classes, dictionary objects, software components,
name spaces and proxies (if using SAP XI / PI), program input/output parameters, etc just to
name a few. Following the guideline for the project helps maintain a consistent coding approach
and also helps other functional and technical analysts to read and debug your code. ABAP
objects naming should begin with Z if it will be migrated to SAP production system and Y if it
will not be migrated into the production system.
3. Write and Review Test Cases
The test case documents are written by the business experts or functional SAP consultants in
most SAP implementation projects. But on some SAP implementation projects a programmer
may be required to write test cases. Before writing a test case review the functional specification
document thoroughly and review the written test case with the business users or functional
consultants. Get a sign-off as mentioned in most steps in this article. As an ABAP Development
Manager for a variety of SAP implementation projects, my goal has been to keep my team
motivated and always cover the team against any change of scope on the development tasks.

2. Having a sign-off at each phase of a SAP custom development or enhancement tasks always
helps the SAP implementation team and project management team keep in sync which is a vital
to complete the SAP implementation in time and budget.
4. Write and Review Technical Design Specifications
Read the functional specification and list all the development objects that would be needed to
implement the required functionality in the SAP system. First step is to draw a flowchart and
review with technical and business experts. The technical design document should include a
technical overview, list of new database objects, ABAP objects that can be reused, a data model
and class diagram (if using ABAP OO classes). It is highly recommended to have a rough
prototype in the sandbox system (Development system if no SAP sandbox system is available) if
the development being done is complex or if the end deliverable is not well defined. You should
then review your prototype with functional experts and business users. Make sure that the ABAP
Development team lead or manager signs off on the prototype. If effort required to complete the
ABAP programming task is not presented and approved by the senior project management then
this would be a good time to get the development estimate and timeline approved.
5. Realization of the Specification – ABAP Development
During this step you will be creating development objects and implementing the code in the SAP
development system. Before you begin, if prototype was done in the sandbox system then
analyze the prototype and design specification. Remember that quality and reusability of existing
ABAP objects are more important than strictly following the design specification. Determine
which existing dictionary objects can be reused for this topic. If new dictionary objects or classes
needs to be created then ensure that these objects can be extended and reused for other
development tasks. It may require extra effort to develop objects that are reusable and flexible.
This one time effort for building reusable ABAP objects during the course of a development
project can potentially save a lot of work for programming similar objects that could otherwise
utilize already built objects. Review your approach with an SAP technical team lead or a
development manager on your project before deviating from the technical design specification
and implementing your own ideas. If you are involved in SAP XI (now Process Integration)
related tasks or creating enterprise services then this is the best area where you could reuse
existing objects. Review the message types that already exist within your SAP business unit and
see if any existing messages can be extended with new fields. Review with the team lead
whether the communication should be synchronous or asynchronous before you generate
proxies.
6. SAP Development Best Practices
SAP ABAP (or JAVA if working on SAP Netweaver) development best practices should be
followed throughout the development lifecycle of the project. Although this aspect depends on
your project technical manager, I personally have maintained a checklist for developers in my
team on all projects and it has been a tremendous success in delivering high quality output on all
development tasks. Here are a few best practices worth adapting in your project. Check whether
you adhere to all naming conventions as described in the programming standards set for your
implementation project. Include comments in your code to allow someone else to easily
understand your programs. This is particularly helpful when you work in large teams and
multiple people work with same objects. Ensure that you have check for user authorization if you

3. are building transactions or web user-interfaces that will require human interaction. Check that
you do not have ABAP code segments that could take a hit on performance like nested loops,
nested select statements (use views if desired), excess database commits (persistent objects or
buffering alternatives may be a good option), etc. Field symbols are a great asset when it comes
to processing internal tables and also variables with unknown data types that are resolved at
runtime. Field symbols are very similar to concept of using pointers in OO programming
landscape. Check if all exceptions are handled and error messages are communicated accurately
to the end users. As an ABAP programmer it should be well accepted by now that short dumps
should not be OK to occur. All these do occur in unknown special case scenarios the short dumps
should be fixed.
7. ABAP Code Reviews and Performance
As a ABAP programmer you should test your code upon completion for all possible scenarios.
Verify that end results are same as that expected in the documented test cases. Perform ABAP
runtime analysis to check for performance of your code. Seek suggestions from your technical
team lead or manager on how to improve code performance if you notice any red flags during the
runtime analysis. Schedule a formal code review with your mentor or a senior ABAP developer
once the development is completed and tested by all responsible developers. Make any revisions
and retest your code against the desired output as documented in the test scripts. Remember that
code reviews is not to find flaws in your programming but it will only make you a better ABAP
developer and maintain consistency.
8. Documentation
Make sure you write an end user documents with overview of the functionality or enhancement
upon completion. Include screenshots where possible. Prepare documentation keeping in mind
that an end user unfamiliar with your deliverable can read the document and test the
functionality. Include contact information in this document for users to easily reach the SAP
technical team for any questions.
9. User Acceptance Testing
Now that your ABAP coding is completed and reviewed by technical experts, it is time for the
business users to perform a formal user acceptance testing. UAT testers will check whether the
output meets business process requirements and suggest any improvements or modifications to
the delivered functionality. After completion of these fixes or modifications you should request a
formal sign-off on the functionality.
10. Migration to SAP Test System and Production System
Quality assurance engineers will test your functionality in the SAP QA environment to verify
that everything is working in your delivered functionality as tested during user acceptance
testing. Also any problems in transporting your ABAP objects across SAP systems will be
identified and addressed during this step. If no problems are found then your transports will be
approved to be migrated to SAP production system in the next transport cycle.
You have just learned how to be an efficient SAP ABAP Developer or per say a high quality
Senior ABAP expert right from writing specifications until realizing your implementation in
production system. Use this article as a guideline as there are many more aspects to improve

4. yourself to be a good ABAP programmer which is not possible to cover in a brief article like this
one. You can always contact me with any suggestions or ideas you may seek for your SAP
implementation.