Contact TLCC

WebSphere Certification Paths

Date tip published:07/13/2005
Description:There are a number of certifications available for WebSphere. This article focuses on the certifications that would be of interest to a WebSphere developer and provide links and tips to pass the exams necessary to become a certified WebSphere developer. This tip has been updated to show the complete set of Rational Developer certifications.


To learn more about getting certified as a WebSphere developer use the following links:

Introduction to WebSphere Using Rational Developer 6
Introduction to WebSphere for Domino Developers using Rational Developer 6
Servlet and JSP Programming for WebSphere using Rational Developer 6
Servlet and JSP Programming using Rational Developer 6 for Domino Developers
Introduction to WebSphere Studio 5
Servlet and JSP Programming using WebSphere Studio 5
Introduction to WebSphere 5 for Domino Developers
Servlet and JSP Programming using WebSphere 5 for Domino Developers




WebSphere Certification Paths


Why get certified? Certification is a great way to show a level of competency. WebSphere is a new technology and J2EE developers are in demand. A WebSphere certification would be a great addition to a resume. Depending on the level of certification, getting certified requires passing one or a series of multiple-choice exams. You take these exams at a Pearson VUE or Prometric testing center. These testing centers are available world-wide in larger cities.

IBM's certification programs are based upon products and versions. For WebSphere there are a number of certifications available. The following WebSphere products have a certification program available:

    • IBM WebSphere Application Server V6.0
    • IBM WebSphere Application Server V5.0
    • IBM WebSphere Application Server for z/OS V5.0
    • IBM WebSphere Commerce Business Edition V5.5
    • WebSphere Development Studio Client for iSeries V5.0
    • IBM WebSphere Portal V5.0
    • IBM Rational Application Developer V6
    • WebSphere Studio Application Developer V5.1
    • IBM WebSphere Studio V5.0
The certifications available for the server products (like WebSphere Application Server) are designed for administrators. The certifications for the developers are actually based on the development tools, either WebSphere Studio 5.x or Rational Application Developer 6 (the replacement for WebSphere Studio 5.)

There are up to three levels of certification for a product. The entry level certification is the Associate level. The intermediate level of certification is the Solution Developer. The Advanced level is typically called the Advanced or Enterprise level. The exact name used will vary by product. Below are the three levels of certification showing the typical certification titles used for each level.


Currently IBM has the following certifications available for the WebSphere products listed above:
    IBM WebSphere Application Server V6.0
      • IBM Certified System Administrator - WebSphere Application Server Network Deployment V6.0

    IBM WebSphere Application Server V5.0
      • IBM Certified System Administrator - WebSphere Application Server V5.0
      • IBM Certified Advanced System Administrator - WebSphere Application Server V5.0

    IBM WebSphere Application Server for z/OS V5.0
      • IBM Certified Advanced System Administrator - WebSphere Application Server for z/OS, V5.0

    WebSphere Development Studio Client for iSeries V5.0
      • IBM Certified Solution Developer - WebSphere Development Studio Client for iSeries, V5.0

    IBM WebSphere Portal V5
      • IBM Certified System Administrator - IBM WebSphere Portal V5.1
      • IBM Certified Solution Developer - IBM WebSphere Portal V5.1
      • IBM Certified System Administrator - IBM WebSphere Portal V5.0
      • IBM Certified Solution Developer - IBM WebSphere Portal V5.0

    IBM Rational Developer V6
      • IBM Certified Associate Developer - Rational Application Developer for WebSphere Software V6
      • IBM Certified Application Developer - Rational Application Developer for WebSphere Software V6.0
      • IBM Certified Advanced Application Developer - Rational Application Developer for WebSphere Software V6.0

    WebSphere Studio Application Developer V5.1
      • IBM Certified Solution Developer - Web Services Development with WebSphere Studio V5.1

    IBM WebSphere Studio V5.0
      • IBM Certified Associate Developer - WebSphere Studio, V5.0
      • IBM Certified Solution Developer - WebSphere Studio, V5.0
      • IBM Certified Enterprise Developer - WebSphere Studio, V5.0
Notice that the certifications for WebSphere Application Server are for administrators. Developers will be most interested in getting certified on either the IBM Rational Application Developer 6 or IBM WebSphere Studio platforms. Another possible certification of interest for a developer is the WebSphere Portal Certified Solution Developer. The balance of this article will focus on developer related certification.

The requirements for each level will vary based on the product and the actual certification. Some certifications require two exams. Unlike the Lotus certifications, the exam for the Associate level is not required and does not help a developer in getting certified at the Solution or Enterprise level.




Preparing for the Exams

The best way to prepare for the exams is to obtain WebSphere Studio or Rational Application Developer 6 and learn how to use it. The exams are heavily concentrated on the user interface of these tools and it would not be practical to try to study for these exams without using the tools themselves. TLCC has published a tip to help you learn how to obtain and install the free trial version of WebSphere Studio or Rational Application Developer 6:

TLCC has two courses on how to use WebSphere Studio to develop WebSphere applications, a introductory level course and an advanced course that concentrates on advanced topics in servlet and JSP programming. A free trial version of Introduction to WebSphere Studio 5 is available at the TLCC website. TLCC offers two versions of each course. One version is for all developers and runs as a plug-in to WebSphere Studio. A plug-in allows you to take the course right in WebSphere Studio. The other version is for Domino developers. This version runs in the Domino Designer 6 client and also includes information on how to integrate Domino with WebSphere. TLCC also offers courses on Rational Application Developer 6.
Click here for more information on TLCC's WebSphere courses and to try a free demo course.

There is also a Redbook on using WebSphere Studio. This Redbook is over 700 pages long and can also be purchased in hard cover form for $72.
Click here for more information on this Redbook

A Redpiece (draft Redbook) is also available for Rational Application Developer 6 in pdf format.
Click here for more information on this Redpiece

There are several different exam vendors who produce practice exams for the WebSphere certifications. Prometric (a testing company where you can take the real test when you are ready) offers a web-based practice exam for each test. These exams cost $10 each time you take the exam. CertFx also offers practice exams. These exams are installed on your computer and can be retaken at many times as you want. The CertFx exams also offer explanations of each question/answer and are a good way to get ready for the exam. These practice exams are just that -- a way to take a practice exam before you sign up for the real exam.

All of the WebSphere exams will require some knowledge of Java. The next section will provide information on each certification for Rational Application Developer 6, WebSphere Studio 5 and WebSphere Portal (Developer) and will suggest the appropriate learning and study aids such as TLCC courses and practice exams.





Taking the Exams

The exams are available through two testing vendors, Pearson VUE and Prometric (formerly known as Sylvan.) The cost ranges from $75 to $175. Most exams are $150. Below are the links for each test vendor:





IBM Certified Associate Developer - Rational Application Developer for WebSphere Software V6.0

This certification requires only one exam and is a good way to get started on the WebSphere certification path. The required exam is:

Developing with IBM Rational Application Developer for WebSphere Software V6 , Exam 255
The exam focuses on Rational Application Developer 6 (the replacement for WebSphere Studio 5) and how to use its tools to develop web applications including Java applications, servlets, and JavaServer Pages. Some Java experience is useful but the test mostly covers the Java tools and not the language itself. The test requires a passing grade of 67%. The exam is a multiple choice format. Some questions have several correct answers and you have to select all the correct answers to get credit for that question. The cost for this exam is $150.

Hide details for Click here to see the 255 exam objectivesClick here to see the 255 exam objectives

Section 1 - Workbench Basics (15%)
    • Set Workbench preferences
    • Work with perspectives and views
    • Use the import and export wizards
    • Use the Help feature to aid in development activities
    • Use the Local History to compare and replace resources
    • Manage workspaces
Section 2 - Java Development (24%)
    • Create Java projects packages, classes, and methods
    • Manage the Java Build Path
    • Use the Outline view
    • Use the refactoring features
    • Use the Java editor features such as content assist and code formatting
    • Add and organize import declarations
    • Use the Java search function
    • Use the Task and Problems views
    • Use the Hierarchy view
    • Use the resource and project property dialogues
Section 3 - Web Development (20%)
    • Create dynamic and static Web projects
    • Understand classpath and module dependencies
    • Use Page Designer to add and modify HTML, JavaScript, and JSP content
    • Configure Web project properties
    • Understand the available JSF (JavaServer Faces) development tools
    • Understand the available Struts development tools
    • Create and configure Servlets
Section 4 - Databases (5%)
    • Create a database connection
    • Use the SQL Statement wizard
    • Sample contents of a database table
Section 5 - Running Applications (9%)
    • Use WebSphere Application Server V6 to run J2EE applications
    • Create and configure data sources
    • Add and remove projects from the server
    • Run stand-alone Java applications
Section 6 - Debugging and Testing (18%)
    • Manage breakpoints
    • Step through and examine Java code
    • View variables and execute, display and inspect expressions
    • Create and run code in Scrapbook page
    • Perform JSP debugging
    • Use step-by-step debugging
    • Locate and view WebSphere application server logs
    • Perform unit testing using JUnit
Hide details for Practice Exams for the 255 ExamPractice Exams for the 255 Exam

Use the following links to get more information on the practice exams available for this exam:
Hide details for Click here to see the suggested TLCC coursesClick here to see the suggested TLCC courses

TLCC offers two courses to help you get certified as an Associate Developer on Rational Application Developer 6. Both courses cover the same topics (except the course for Domino developers covers Domino integration and requires a Domino Designer 6 client.) Each course will cover the exam objectives above and prepare you for the 255 exam.

For Domino Developers - Introduction to WebSphere for Domino Developers Using Rational Developer 6 (TLCC also offers Java courses for Domino Developers)
For all other developers - Introduction to WebSphere Using Rational Developer 6





IBM Certified Application Developer - Rational Application Developer for WebSphere Software V6.0

This certification requires only one exam. The required exam is:

Test 256: Application Development with IBM Rational Application Developer for WebSphere Software V6.0
The exam focuses on Rational Developer 6 and also focuses heavily on web services and EJBs. The test requires a passing grade of 54% or 56%. The exam is a multiple choice format. The cost for this exam is $150.
Hide details for Click here to see the 256 exam objectivesClick here to see the 256 exam objectives

Section 1 - Workbench Basics (9%)
    • Manage multiple workspaces
    • Work with perspectives (e.g. add, remove, customize)
    • Import to and export from the Workbench
    • Use Compare With and Replace With using the Local History function
Section 2 - Application Development Best Practices (9%)
    • Partition an application into appropriate Model View Controller (MVC), MVC2, and Model 2 JSP architectures
    • Apply basic Java design patterns (e.g., session facade, data transfer object)
    • Improve application performance through design best practices
Section 3 - Java Development (16%)
    • Create Java projects, packages, classes, interfaces, methods
    • Use the search function
    • Use the call hierarchy View
    • Refactor Java code
    • Set Java workbench preferences (e.g., change JRE, change target server)
    • Understand the results of Java code visualization
Section 4 - Web Development (16%)
    • Create web projects and resources
    • Configure classpath and module dependencies
    • Use the Page Designer to develop HTML and JSP pages
    • Work with Web and Application Deployment Descriptor Editors
    • Use the JSF (JavaServer Faces) development tools
    • Use the Struts development tools
    • Create and configure Servlet Filters and Life-cycle Listeners
Section 5 - EJB Development (12%)
    • Create EJB projects
    • Create session beans
    • Create and map CMP entity beans without relationships
    • Test EJBs using the Universal Test Client
    • Import database schema into a project
Section 6 - Web Services (12%)
    • Create Web services from JavaBeans
    • Create Web services from a WSDL document
    • Use the Web Services Explorer to test Web services
    • Build and modify a WSDL document using the WSDL editor
    • Create a Web service client and proxy
Section 7 - Running Applications (14%)
    • Configure a WebSphere test environment and run applications
    • Configure application resources on servers
    • Configure J2EE application clients
    • Configure workbench for profiling applications
    • Simplify deployment using enhanced EAR
Section 8 - Debugging & Testing (12%)
    • Manage breakpoint properties
    • View variables and execute, display and inspect expressions
    • Use step filters and step debug (Servlet, JSP, or EJB)
    • Work with activity logs and symptom database
    • Perform Java testing using JUnit
    • Perform application analysis using code review
Hide details for Practice Exams for the 256 ExamPractice Exams for the 256 Exam

Use the following link to get more information on the practice exams available:
Hide details for Click here to see the suggested TLCC coursesClick here to see the suggested TLCC courses

TLCC does not currently offer a course to fully prepare for this exam. The courses below will help but does not cover Web Services or EJBs.

For Domino Developers - Servlet and JSP Programming using Rational Developer 6 for Domino Developers
For all other developers - Servlet and JSP Programming for WebSphere using Rational Developer 6




IBM Certified Advanced Application Developer - Rational Application Developer for WebSphere Software V6.0

This certification requires only one exam. The required exam is:

Test 257: Enterprise Application Development with IBM Rational Application Developer for WebSphere Software V6.0
The exam covers what was in the 256 test (above) but also covers the Java APIs in J2SE 1.4 and J2EE 1.4. The following APIs may be covered: EJB, Servlet, JSP, JSF, Struts, JDBC, and Web Services. The test requires a passing grade of 65% or 67%. The exam is a multiple choice format. The cost for this exam is $150.
Hide details for Click here to see the 257 exam objectivesClick here to see the 257 exam objectives

Section 1 - Web Component Design and Implementation (14%)
    • Design, develop and test Java Servlets, Filters and Life-cycle Listeners
    • Design, develop and test JSPs, JSF and Struts applications
    • Manage end-user state and consider tradeoffs of using different session management techniques
    • Create and use custom tag libraries to deliver dynamic content to JSPs
Section 2 - EJB Design and Implementation (30%)
    • Design and develop EJBs
    • Design an EJB module using EJB visualization
    • Create and configure container-managed relationships
    • Create EJB queries using EJB Query Language
    • Manipulate transactional behavior of EJBs using deployment descriptors
    • Access container services from EJBs
    • Implement EJB clients in Java
    • Test and debug EJBs
Section 3 - Web Services (12%)
    • Create Web services from EJB sources
    • Consider issues related to Web services interoperability (WS-I) compliance level settings
    • Configure JAX-RPC handlers
    • Implement Java clients calling Web services
Section 4 - Database Connectivity and Messaging (8%)
    • Configure data sources
    • Set up a service integration bus
    • Configure JMS connection factories and destinations
Section 5 - Security (10%)
    • Map users and groups to roles
    • Apply declarative role-based security to EJBs and Web components
    • Configure JAAS aliases for resource authentication
    • Configure login authentication method for Web applications
Section 6 - Validation, Tuning & Troubleshooting of the Development Runtime Environment (16%)
    • Use tracing and profiling tools to analyze and tune applications
    • Perform problem determination on application components
    • Understand conditions for restarting modules and servers
    • Use Component Test features
Section 7 - Assembly and Deployment (10%)
    • Assemble Web components, EJB components, and application client components into enterprise applications
    • Deploy an enterprise application to a WebSphere application server
    • Create and configure WebSphere test servers
    • Switch the database back end of EJB applications
Hide details for Practice Exams for the 257 ExamPractice Exams for the 257 Exam

Use the following link to get more information on the practice exams available:
Hide details for Click here to see the suggested TLCC coursesClick here to see the suggested TLCC courses

TLCC does not currently offer a course to fully prepare for this exam. The courses below will help but does not cover Web Services or EJBs or completely cover the Java APIs listed in the objectives.

For Domino Developers - Servlet and JSP Programming using Rational Developer 6 for Domino Developers
For all other developers - Servlet and JSP Programming for WebSphere using Rational Developer 6




IBM Certified Associate Developer - WebSphere Studio, V5.0

This certification requires only one exam and is a good way to get started on the WebSphere certification path. The required exam is:

Developing with WebSphere Studio, V5.0, Exam 285
The exam focuses on WebSphere Studio and how to use its tools to develop web applications including Java applications, servlets, and JavaServer Pages. Some Java experience is suggested but you do not have to be a Java coding guru. Most of the Java related questions deal with WebSphere Studio's Java tools like the debugger and not Java itself, so an intensive knowledge of Java programming is not required. The test requires a passing grade of 53%. There are many detailed questions on the WebSphere interface which add to the test's difficulty (and probably is why the passing grade is so low.) The exam is a multiple choice format. Some questions have several correct answers and you have to select all the correct answers to get credit for that question. The cost for this exam is $125.

Hide details for Click here to see the 285 exam objectivesClick here to see the 285 exam objectives

Section 1 - Workbench Basics (16%)
    • Create J2EE projects
    • Set workbench preferences
    • Work with perspectives
    • Import to and export from the workbench
    • Use the Help feature to aid in development activities
Section 2 - Java Development (27%)
    • Create Java project, packages, classes, methods
    • Use outline view
    • Use Java browsing view
    • Use refactoring features
    • Use content assist function
    • Add and organize import declarations
    • Use search function
    • Use task view
    • Use hierarchy view
    • Use property dialogues
Section 3 - Web Development (20%)
    • Create a web project
    • Create resources in appropriate J2EE locations
    • Understand classpath and module dependencies
    • Use Page Designer to add and modify HTML and JSP content, including the use of JavaScript
    • Use content assist
    • Work with Web Application Deployment Descriptor using web.xml editor
    • Use Web Page Wizards
Section 4 - Running Applications (12%)
    • Create server instance and server configuration
    • Configure data sources
    • Understand session manager
    • Run/operate server
    • Export J2EE applications
Section 5 - Debugging (18%)
    • Set breakpoints
    • Step-through code
    • View variables (e.g., display expressions and use inspectors)
    • Create and run code in Scrapbook Page
    • Perform JSP debugging
Section 6 - Data (8%)
    • Create connection and load catalog into a project
    • Create schema and generate DDL
    • Use query builder to generate queries
Hide details for Practice Exams for the 285 ExamPractice Exams for the 285 Exam

Use the following links to get more information on the practice exams available for this exam:
Hide details for Click here to see the suggested TLCC coursesClick here to see the suggested TLCC courses

TLCC offers two courses to help you get certified as an Associate Developer on WebSphere Studio. Both courses cover the same topics (except the course for Domino developers covers Domino integration and requires a Domino Designer 6 client.) Each course will cover the exam objectives above and prepare you for the 285 exam.

For Domino Developers - Introduction to WebSphere 5 for Domino Developers (TLCC also offers Java courses for Domino Developers)
For all other developers - Introduction to WebSphere 5





IBM Certified Solution Developer - WebSphere Studio, V5.0

The Solution Developer certification requires two exams. Note that you do not have to become certified as an Associate Developer first since the 285 exam is not part of this certification. The first exam is Test 286, Application Development with IBM WebSphere Studio, V5.0. The 286 exam primarily concentrates on the WebSphere Studio development tool. The second exam is not WebSphere Studio oriented and is designed to test a developer's web development skills. There are several options for this second exam. IBM offers the exam Test 154 - Web Developer to test for this skill. They also accept other organization's exams that test similar web development or Java skills. These are listed below.

Exam requirements for the Certified Solution Developer - WebSphere Studio:

    1. Test 286, Application Development with IBM WebSphere Studio, V5.0
    2. Test 154 - Web Developer (more on this exam later)

Or any one of the following exams may be substituted for the 154 exam:
As you can see there are several ways to achieve this certification. The good news is that in the course of becoming a Certified Solution Developer on WebSphere Studio you will also earn another certification. The CIW exam is the same exam as IBM's 154 exam. If you take either the 154 exam or the CIW exam (1D0-532) then you also will be certified as a CIW Web Developer. And passing the Sun exam will earn you a Sun Certified Programmer certification. Which exam to take? That depends on you ... if you are comfortable with Java and are new to J2EE development than the Sun exams might be a better choice. If you are very familiar with J2EE development and web services than the Web Developer exam might be better. Review the test objectives for the Web Developer exam and the Sun exam and decide which option is a better fit for your skills. Below is more information on each exam and how to prepare for that exam.

Test 286, Application Development with IBM WebSphere Studio, V5.0
This exam is very similar to the 285 exam. It concentrates mostly on WebSphere Studio's tools and interface. The required passing score is 65%. The exam is a multiple choice format. Some questions have several correct answers and you have to select all the correct answers to get credit for that question. EJB's are not covered on this exam.
Hide details for Click here to see the 286 exam objectivesClick here to see the 286 exam objectives

Section 1 - WorkBench Basics (11%)
    • Create J2EE projects
    • Manage multiple workspaces
    • Work with perspectives (e.g., add, remove, customize)
    • Import to and export from the Workbench
    • Use Compare With and Replace With using the Local History function
    • Use the team programming tools
Section 2 -Application Development Best Practices (11%)
    • Partition an application into appropriate layers
    • Apply server-side design patterns
    • Improve application performance
Section 3 - Java Development (22%)
    • Create Java projects, packages, classes, interfaces, methods
    • Use outline view with filters
    • Use Content Assist and Quick Fix
    • Add and organize import declarations
    • Use search function
    • Use task view
    • Use hierarchy view
    • Refactor Java code
    • Use property dialogues
    • Use JUnit
    • Set Java workbench preferences
Section 4 -Web Development (24%)
    • Create web projects and resources in appropriate J2EE locations
    • Configure classpath and module dependencies
    • Use Page Designer to add and modify HTML, Javascript and JSP content
    • Use content assist on web resources
    • Use tag libraries to deliver dynamic content to JSPs
    • Work with Web Application Deployment Descriptor (web.xml file)
    • Use Web Page Wizards and Struts tools
    • Export J2EE applications
Section 5 - Running Applications (7%)
    • Configure the WebSphere Test Environment and run applications
    • Configure applications on remote servers
Section 6 -Debugging Applications (13%)
    • Set breakpoints
    • Step through code
    • View and inspect variables and expressions
    • Understand conditions for restarting modules and servers
    • Create and run code in Scrapbook Page
    • Perform JSP debugging
    • Perform remote debugging
    • Work with logs and traces
Section 7 -Profiling Applications (6%)
    • Set up profiling
    • Use views to analyze results
    • Set up filters
Section 8 - Data (6%)
    • Create connection and load catalog into a project
    • Create schema and generate DDL
    • Use query builder to generate queries
Hide details for Practice Exams for the 286 ExamPractice Exams for the 286 Exam

Use the following links to get more information on the practice exams available for this exam:
Hide details for Click here to see the suggested TLCC coursesClick here to see the suggested TLCC courses

TLCC offers two courses to help you get certified as an Associate Developer on WebSphere Studio. Both courses cover the same topics (except the course for Domino developers covers Domino integration and requires a Domino Designer 6 client.) Each course will cover the exam objectives above and prepare you for the 286 exam.

For Domino Developers - Servlet and JSP Programming using WebSphere 5 for Domino Developers
(TLCC also offers Java courses for Domino Developers)
For all other developers - Servlet and JSP Programming using WebSphere Studio 5



Test 154 - Web Developer
This exam tests your knowledge on web development, JavaScript, servlets, JSPs and web services. Below are the objectives and some suggested study aids. A passing grade is 55%.
Hide details for Click here to see the 154 exam objectivesClick here to see the 154 exam objectives
Section 1 - Writing Application Control Logic (28%)
    • Create, declare and map a class that extends HttpServlet or a subclass of HttpServlet
    • Programmatically build URLs, including URL encoding, selecting the protocol and adding query string information
    • Query and extract all relevant information from the HttpServletRequest object
    • Delegate display from the servlet to the appropriate display agent
    • Record and manage state using the four scopes
    • Obtain and use initialization and context parameters
    • Identify the key elements and the role of the WAR file
    • Identify key multithreading issues and their effects on HttpServlet performance
    • Apply session management to situations such as session invalidation, and concurrent access to session resources
    • Ensure that a servlet enforces pre- and post-processing conditions as a controller, such as appropriate state, proper error codes, etc
    • Implement a filter to manipulate servlet requests and responses
    • Implement event listeners for a servlet
    • Create a serializable object and list when it may be used with respect to clustered and persistent sessions
Section 2 - Writing Application Display Logic (32%)
    • Build an HTML page using tables and forms
    • Write JSP code to maximize browser compatibility, such as including ALT attributes in tags, providing XML support, and retrieving the User-Agent header value
    • Use JavaScript (ECMA-262) for client-side processing, such as data validation and presentation enrichment
    • Embed an applet in HTML
    • Use local styles and Cascading Style Sheets (CSS) in an HTML page
    • Control page processing through the HTML header with settings such as enabling\disabling caching, meta information, pragma settings, etc
    • Access a JavaBean and its associated state in the correct scope using the useBean and other related action tags
    • Identify, construct and use valid JSP scripting elements such as expressions, scriptlets and declarations to display dynamic content
    • Identify and implement valid JSP directives, such as page, include, taglib, etc
    • Implement exception handling in JSP, including the use of JSP error pages
    • Declare and use a pre-existing custom tag library in a JSP file
    • Create a simple well-formed WML document utilizing WML-specific tags
    • Define the role of XSLT in enabling document conversion, such as HTML to WML
    • Identify the implications of displaying graphics on a wireless device
    • Identify the HTML elements that are sensitive to internationalization and localization
    • Match the XML-based JSP tags to the traditional (legacy) JSP tags
Section 3 - Utilizing Business Services (25%)
    • Locate an object such as a DataSource, EJB reference or connection factory in a JNDI namespace
    • Handle J2EE exceptions such as NamingException, JMS exceptions, resource exceptions, JDBCException, transaction and EJB-related exceptions
    • Obtain and release JDBC resources such as connections using JDBC 2.0-compliant data sources
    • Create and use JDBC statements including prepared and callable statements
    • Navigate and read a ResultSet using the JDBC 2.0 API
    • Use the J2EE Connector Architecture common client interface to send and extract data from a J2EE service
    • Obtain and use an EJBHome or EJBLocalHome interface
    • Obtain and use a remote or local interface for an enterprise bean
    • Distinguish between various forms of enterprise beans and the ways that each is used
    • Create and use JMS Sessions to send and receive messages
    • Identify and distinguish between the models in the JMS architecture, such as point-to-point and publish subscribe
    • Create a Message object using the correct type for the data being used
    • Connect to JavaMail to send and receive mail
Section 4 - Exposing Application Components Using Web Services (15%)
    • Read and write a file that conforms to the syntax of an XML application using one or more namespaces based on a DTD/XSD. Identify and resolve errors in a SOAP message
    • Modify settings in a WSDL file, including those that relate to implementation and binding
    • Compare and contrast the roles of UDDI, WSDL and SOAP as used by service providers, service consumers and service brokers
    • Identify the basic aspects of Web Services, such as components that can be used to implement them, differences between synchronous and asynchronous Web Services, etc
    • Write a client integrating a given Web Service using JAX-RPC and JAXM
Hide details for Practice Exams for the 154 ExamPractice Exams for the 154 Exam

Use the following links to get more information on the practice exams available for this exam:
Hide details for Click here to see the suggested TLCC coursesClick here to see the suggested TLCC courses

TLCC does not specifically offer a course to help you with the 154 exam. Below are several web-related courses that cover some of the topics on the 154 exam. Note that there are still topics on the exam not covered in the courses below. Consult the 154 exam objectives and the CIW website for more information on how to study for this exam.

For Domino Developers: For all Developers:


Test 310-035, Sun Certified Programmer for the Java 2 Platform 1.4
This exam concentrates solely on Java programming. No web development techniques or J2EE topics like servlets or JSPs are covered. If you are a strong programmer and not as strong in web development than this might be a better way to go. The passing grade is 52% and the exam is multiple choice. The exam costs $150 and is available through Prometric like the IBM exams. There is also an exam from Sun for version 1.2 of Java which can be used to satisfy the exam requirement.
Hide details for Click here to see the Sun exam objectivesClick here to see the Sun exam objectives

Section 1: Declarations and Access Control
    • Write code that declares, constructs and initializes arrays of any base type using any of the permitted forms both for declaration and for initialization.
    • Declare classes, nested classes, methods, instance variables, static variables and automatic (method local) variables making appropriate use of all permitted modifiers (such as public, final, static, abstract, etc.). State the significance of each of these modifiers both singly and in combination and state the effect of package relationships on declared items qualified by these modifiers.
    • For a given class, determine if a default constructor will be created and if so state the prototype of that constructor.
    • Identify legal return types for any method given the declarations of all related methods in this or parent classes.
Section 2: Flow control, Assertions, and Exception Handling
    • Write code using if and switch statements and identify legal argument types for these statements.
    • Write code using all forms of loops including labeled and unlabeled, use of break and continue, and state the values taken by loop counter variables during and after loop execution.
    • Write code that makes proper use of exceptions and exception handling clauses (try, catch, finally) and declares methods and overriding methods that throw exceptions.
    • Recognize the effect of an exception arising at a specified point in a code fragment. Note: The exception may be a runtime exception, a checked exception, or an error (the code may include try, catch, or finally clauses in any legitimate combination).
    • Write code that makes proper use of assertions, and distinguish appropriate from inappropriate uses of assertions.
    • Identify correct statements about the assertion mechanism.
Section 3: Garbage Collection
    • State the behavior that is guaranteed by the garbage collection system.
    • Write code that explicitly makes objects eligible for garbage collection.
    • Recognize the point in a piece of source code at which an object becomes eligible for garbage collection.
Section 4: Language Fundamentals
    • Identify correctly constructed package declarations, import statements, class declarations (of all forms including inner classes) interface declarations, method declarations (including the main method that is used to start execution of a class), variable declarations, and identifiers.
    • Identify classes that correctly implement an interface where that interface is either java.lang.Runnable or a fully specified interface in the question.
    • State the correspondence between index values in the argument array passed to a main method and command line arguments.
    • Identify all Java programming language keywords. Note: There will not be any questions regarding esoteric distinctions between keywords and manifest constants.
    • State the effect of using a variable or array element of any kind when no explicit assignment has been made to it.
    • State the range of all primitive formats, data types and declare literal values for String and all primitive types using all permitted formats bases and representations.
Section 5: Operators and Assignments
    • Determine the result of applying any operator (including assignment operators and instance of) to operands of any type class scope or accessibility or any combination of these.
    • Determine the result of applying the boolean equals (Object) method to objects of any combination of the classes java.lang.String, java.lang.Boolean and java.lang.Object.
    • In an expression involving the operators &, |, &&, || and variables of known values state which operands are evaluated and the value of the expression.
    • Determine the effect upon objects and primitive values of passing variables into methods and performing assignments or other modifying operations in that method.
Section 6: Overloading, Overriding, Runtime Type and Object Orientation
    • State the benefits of encapsulation in object oriented design and write code that implements tightly encapsulated classes and the relationships "is a" and "has a".
    • Write code to invoke overridden or overloaded methods and parental or overloaded constructors; and describe the effect of invoking these methods.
    • Write code to construct instances of any concrete class including normal top level classes and nested classes.
Section 7: Threads
    • Write code to define, instantiate and start new threads using both java.lang.Thread and java.lang.Runnable.
    • Recognize conditions that might prevent a thread from executing.
    • Write code using synchronized wait, notify and notifyAll to protect against concurrent access problems and to communicate between threads.
    • Define the interaction among threads and object locks when executing synchronized wait, notify or notifyAll.
Section 8: Fundamental Classes in the java.lang Package
    • Write code using the following methods of the java.lang.Math class: abs, ceil, floor, max, min, random, round, sin, cos, tan, sqrt.
    • Describe the significance of the immutability of String objects.
    • Describe the significance of wrapper classes, including making appropriate selections in the wrapper classes to suit specified behavior requirements, stating the result of executing a fragment of code that includes an instance of one of the wrapper classes, and writing code using the following methods of the wrapper classes (e.g., Integer, Double, etc.):
      • doubleValue
      • floatValue
      • intValue
      • longValue
      • parseXxx
      • getXxx
      • toString
      • toHexString
Section 9: The Collections Framework
    • Make appropriate selection of collection classes/interfaces to suit specified behavior requirements.
    • Distinguish between correct and incorrect implementations of hashcode methods.
Hide details for Practice Exams for the Sun examPractice Exams for the Sun exam

Use the following links to get more information on the practice exams available for this exam:
Hide details for Click here to see the suggested TLCC coursesClick here to see the suggested TLCC courses

TLCC offers two Java programming courses. These courses will help you get started learning Java. Note that there are advanced topics on the exam which are not covered in the TLCC courses. Both courses are designed for Domino Developers and require a Domino Designer 6 client (R5 versions also are available.)






IBM Certified Enterprise Developer - WebSphere Studio, V5.0

This is the highest level of certification for WebSphere Studio. This certification requires four exams. The primary area of focus is EJBs. One of the required exams is the 310-035 (or the Java 1.2 equivalent). The exam requirements are:

  1. Test 310-035: Sun Certified Programmer for the Java 2 Platform 1.4
  2. Test 486: Object-Oriented Analysis and Design with UML
  3. Test 484: Enterprise Connectivity with J2EE V1.3
  4. Test 287: Enterprise Application Development with IBM WebSphere Studio, V5.0

Test 486: Object-Oriented Analysis and Design with UML
The passing score on this exam is 67%.
Hide details for Click here to see the 486 exam objectivesClick here to see the 486 exam objectives
Section 1 - Development Process (13%)
    • Apply iterative and incremental processes.
    • Schedule project activities based on use cases.
    • Exhibit the ability to trace requirements both forward and backward through OOAD artifacts.
    • Utilize use cases to drive other project activities.
    • Apply the appropriate OOAD activities for a given situation, based on their strengths and weaknesses.
    • Control and coordinate the interfaces between packages.
    • Organize the project team responsibilities based on OOAD artifacts.
Section 2 - Requirements Modeling (18%)
    • Identify skills and resources needed to write use cases.
    • Identify actors for the system.
    • Identify use cases from a requirement document and/or domain expert and extract business rules for the domain.
    • Develop and interpret a use case model using the UML notation.
    • Write use cases that focus on the problem domain.
    • Write use cases using the terminology of the target audience.
    • Derive subsequent OOAD artifacts from use cases.
    • Use a prototype of the user interface for customer feedback when appropriate.
Section 3 - Architecture (13%)
    • Develop layered architectures and understand how the layers should interact.
    • Use package diagrams when appropriate, creating and interpreting contractual interfaces and dependencies between packages.
    • Use cohesion and coupling effectively when grouping classes into packages.
    • Use deployment diagrams effectively.
    • Apply brokering to build flexible systems.
    • Consider issues related to scalability, performance, transactions and concurrency.
Section 4 - Static Modeling (21%)
    • Identify domain objects, services, attributes, and their relationships using different techniques, including "parts of speech".
    • Determine when a new class is needed.
    • Choose good names for classes and methods.
    • Describe the business concept and role that each class represents in the domain model.
    • Develop and interpret UML class diagrams, including the effective use of aggregation, generalization and delegation.
    • Effectively interpret and develop associations in class diagrams, including stereotypes, qualified associations, cardinality of associations, and association classes.
    • Maintain encapsulation of attributes and visibility of operations effectively.
    • Recognize and exploit polymorphism.
    • Create, interpret and exploit interfaces.
    • Interpret class diagrams from analysis and design perspectives, recognizing proper use of subclassing and subtyping.
Section 5 - Dynamic Modeling (22%)
    • Focus on behavior while modeling the domain.
    • Include an appropriate level of detail in diagrams.
    • Effectively assign responsibilities to appropriate classes.
    • Develop UML interaction diagrams (sequence and collaboration) to satisfy requirements.
    • Interpret interaction diagrams, including the use of iterations, conditionals and concurrency.
    • Recognize complexities early in the project and resolve them in an iterative and incremental fashion.
    • Determine when to use state diagrams.
    • Develop and interpret UML state diagrams, including the use of events, guards, actions, and super state.
    • Determine when to use activity diagrams.
    • Develop and interpret UML activity diagrams, including concurrency, iterations, and conditionals.
Section 6 - Design & Implementation Techniques (13%)
    • Design for reuse.
    • Given its definition, apply a pattern.
    • Refactor classes to distribute responsibilities and behavior.
    • Carry OOAD artifacts forward into implementation.
    • Resolve implementation issues and update OOAD artifacts.
Hide details for Practice Exams for the 486 examPractice Exams for the 486 exam

Use the following links to get more information on the practice exams available for this exam:


Test 484: Enterprise Connectivity with J2EE V1.3
The passing score on this exam is 63%.
Hide details for Click here to see the 484 exam objectivesClick here to see the 484 exam objectives
Section 1 - Java 2 Enterprise Edition (J2EE) Architecture (18%)
    • Select and apply appropriate J2EE technologies to design the desired multi-tiered architecture
    • Evaluate tradeoffs in designing distributed systems
    • Select appropriate J2EE design patterns
    • Assign responsibility to appropriate layers to optimize maintainability, scalability and performance
Section 2 -Web Component Development (19.5%)
    • Construct Web pages to provide dynamic content using JavaServer Pages (JSPs)
    • Design and develop Java Servlets conforming to the Java Servlet Specification, including Servlet life cycle, classes, interfaces, events, listeners, and filters
    • Coordinate and manage session state, including cookies, HttpSession and URL rewrite
    • Implement robust controller logic which also supports effective error handling
    • Separate component responsibilities as structured using MVC (Model-View-Controller
Section 3 - Enterprise JavaBean (EJB) Development (27%)
    • Select and understand types of EJBs
    • Design EJB local and remote interfaces
    • Design logic compatible with EJB lifecycle and state behavior, including creation, activation, passivation and removal
    • Develop Entity EJBs with Container-Managed Persistence (CMP), using the EJB query language and Container-Managed Relationships (CMR), or Bean Managed Persistence (BMP)
    • Develop message-driven beans (MDB)
    • Utilize exceptions in the context of distributed objects and container-managed transactions
Section 4 - Client Development (9%)
    • Identify and resolve issues of enterprise client programming, including application, servlet and EJB clients
    • Use Java Naming and Directory Interface (JNDI) to obtain both local and global references to services
Section 5 - Connectivity Services (19.5%)
    • Select and use connectivity technologies, including Java Messaging Service (JMS), JDBC, J2EE Connector Architecture, and enterprise connectivity services
    • Identify and resolve Remote Method Invocation (RMI) issues for J2EE application design, including serialization, RMI-IIOP and remote exception
    • Use JDBC 2.0 to access relational databases, including driver and statement selection
    • Apply JDBC 2.0 standard extension features including DataSources, connection pooling and transaction management
    • Use Java Messaging Service (JMS) for application integration
    • Use Java API for XML Parsing (JAXP) for XML processing
    • Use Java Authentication and Authorization Service (JAAS) to secure your application
Section 6 - Assembly and Deployment (7%)
    • Package enterprise applications for portable deployment
    • Use J2EE deployment descriptors to configure enterprise applications for deployment
Hide details for Practice Exams for the 484 examPractice Exams for the 484 exam

Use the following links to get more information on the practice exams available for this exam:



Test 287: Enterprise Application Development with IBM WebSphere Studio, V5.0
The passing score on this exam is 62%.
Hide details for Click here to see the 287 exam objectivesClick here to see the 287 exam objectives

Section 1 - Design, build and test reusable enterprise components (25%)
    • Design and develop session EJBs
    • Design and develop message-driven EJBs
    • Design and develop entity EJBs
    • Access container and server services from enterprise components
    • Implement mechanisms for efficient inter-component calls
    • Test and debug enterprise components
Section 2 - Design, build and test web components (19%)
    • Design, develop and test Java Servlets, filters and listeners
    • Design, develop and test JSPs
    • Manage end-user state and understand performance tradeoffs of using HTTP sessions
    • Design and develop custom tags
Section 3 - Develop clients that access the enterprise components (8%)
    • Implement Java clients calling EJBs
    • Implement Java clients calling web services
    • Implement mechanisms which support loose coupling between clients and components
Section 4 - Demonstrate understanding of database connectivity and messaging within IBM WebSphere Application Server (8%)
    • Create, configure, and tune connection pools
    • Interact with connection pools to obtain and release connections
    • Configure JMS connection factories and destinations
Section 5 - EJB transactions (10%)
    • Build EJBs which satisfy transactional requirements
    • Use JTA to control transaction demarcation
    • Manipulate transactional behavior of EJBs using deployment descriptors
Section 6 - Assemble enterprise applications and deploy them in IBM WebSphere Application Server (15%)
    • Assemble web components, EJB components, and client application components into enterprise applications
    • Deploy enterprise applications into servers
    • Configure resource and security-role references
    • Create and configure WebSphere test environment servers
Section 7 - Validate, tune and troubleshoot an application within an IBM WebSphere Application Server environment (15%)
    • Use tracing and profiling tools to analyze and tune applications
    • Explain implications of resource management on application design and implementation
    • Identify misbehaving application components
    • Describe the effects of a server failure on the application
    • Validate operational parameters of application server to support the enterprise application
Hide details for Practice Exams for the 287 examPractice Exams for the 287 exam

Use the following links to get more information on the practice exams available for this exam:




IBM Certified Solution Developer - IBM WebSphere Portal V5.1


This certification requires only one exam and none of the other certifications are required for this certification.

Test 399: IBM WebSphere Portal V5.1, Application Development
The passing score on this exam is 56%.

Hide details for Click here to see the 399 exam objectivesClick here to see the 399 exam objectives

Section 1 - Install, Set up and Configure the Development Environment (8%)
    • Understand software prerequisites
    • Choose development scenarios (Topologies)
    • Diagnose problems with development environment installation
Section 2 - Architecting a Portal Solution (12%)
    • Identify portal dependencies on existing software
    • Use out-of-the-box portlets
    • Search the Workplace Solutions Catalog
    • Size the custom portlets that have to be written
    • Develop themes, skins and screens
Section 3 - Write a Portlet (43%)
    • Describe the portlet life cycle
    • Develop Portlet applications utilizing Portlet JSR 168 API core objects
    • Effectively utilize portlet configuration and state objects to control portlet behavior
    • Effectively utilize portlet modes and states
    • Implement action processing
    • Use APIs to forward and redirect URLs
    • Support multiple markup
    • Embed references to resources within a portlet
    • Effectively use JSPs to supply portlet rendering markup
    • Support multiple locales, clients and devices within a portlet application
    • Compile and package a WAR file
    • Work with portlet deployment descriptors (caching)
    • Make effective use of portlet application wizards
Section 4 - Testing and debugging a Portal Solution (12%)
    • Set up portlet parameters
    • Debug a portlet using a local Portal Unit Test Environment (UTE)
    • Debug a portlet using WebSphere Portal remote server attach
    • Troubleshoot portlet applications
Section 5 - Backend Porlet Services (17%)
    • Use a portlet service
    • Create a portlet service
    • Configure and access application-specific data sources
    • Use Service Data Objects (SDO) tooling to enable access to remote systems
    • Utilize the credential vault service
    • Implement cooperative portlets
Section 6 - Additional Portlet Concepts (8%)
    • Use struts concepts within the portal framework and JavaServer Faces
    • Implement personalization within portlet application
    • Utilize business process engine (bpe) API
Hide details for Practice Exams for the 399 examPractice Exams for the 399 exam

Use the following links to get more information on the practice exams available for this exam:




IBM Certified Solution Developer - IBM WebSphere Portal V5.0


This certification requires only one exam and none of the other certifications are required for this certification.

Test 348: IBM WebSphere Portal V5.0, Application Development
The passing score on this exam is 54%.

Hide details for Click here to see the 348 exam objectivesClick here to see the 348 exam objectives

Section 1 - Install, set up and configure the development environment (6%)
    • Understand software prerequisites [incl. compatibility questions]
    • Choose development scenarios [Topologies]
    • Diagnose problems with development environment installation
Section 2 - Architect, implement and design a portal solution (12%)
    • Identify portal dependencies on existing software
    • Use out-of-the-box portlets
    • Search the portlet catalog
    • Size the custom portlets that have to be written
    • Develop themes, skins and screens using engine tag library
Section 3 - Write a portlet (43%)
    • Describe the portlet life cycle
    • Develop Portlet applications utilizing Portlet API core objects
    • Effectively utilize portlet configuration and state objects to control portlet behavior
    • Effectively utilize portlet modes and states
    • Implement event handling
    • Create portlet actions
    • Use APIs to forward and redirect URLs
    • Support multiple markup
    • Embed references to resources within a portlet
    • Effectively use JSPs to supply portlet rendering markup
    • Support multiple locales, clients and devices within a portlet application
    • Compile and package a WAR file
    • Work with portlet deployment descriptors (caching)
    • Make effective use of portlet application wizards
Section 4 - Testing and Debugging a Portal Solution (12%)
    • Set up portlet parameters
    • Debug a portlet using the Portal Toolkit
    • Debug a portlet remotely using WebSphere Portal
    • Troubleshoot portlet applications
Section 5 - Backend Portlet Services (10%)
    • Use a portlet service
    • Create a portlet service
    • Configure and access application-specific data sources
    • Access remote systems
Section 6 - Additional Portlet Concepts (16 %)
    • Utilize the credentials vault
    • Implement Cooperative Portlets
    • Implement portlet messaging
    • Use struts concepts within the portal framework
    • Implement Portlet menus
Hide details for Practice Exams for the 348 examPractice Exams for the 348 exam

Use the following links to get more information on the practice exams available for this exam:






Links for More Information

IBM WebSphere Certification Page - This page has links for each WebSphere certification. Each certification than has a page with the required exams, the exam objectives, practice tests, and educational resources.

IBM Rational Certification Page - This page has links for the Rational certifications.

WebSphere Power article on WebSphere exam - This article is about one developer's quest for certification.