HTML/semantics:
Working from a picture or description of a document (preferably one you'd actually see on paper in real life), identify what tags should be used to represent each element. Easier problems might be a document with a clear, structured visual hierarchy (such as a legal document) and use only p, h[1-6], a, strong, em, br. Moderate problems might be something that looks more like a web page, and include ul, ol, dl, etc. Harder problems could be something like a graphically-complex advertisement where the presentation makes the hierarchy and semantic choices less obvious. Another approach would be to present page text that needs to be marked up, similar to past exam problems.

CSS/layout:
Working from a diagram of two or three elements positioned on a page, and/or a description of their desired behavior with respect to each other, come up with the CSS to position the elements so that they behave properly. Easier problems might just focus on aligning vs floating, clearing, basic 'position' property use, and basic box model stuff. Moderate problems could deal with margin collapsing, continuation of block-level elements behind floats, vertical margin/padding gotchas, etc. Harder problems might involve tag choice design decisions, precise sums-of-widths, calculating relative font sizes and line heights, using the 'display' property, and precise pedagogical examples illustrating cases when it's best to use certain layout techniques over others (aligning, floating, positioning, and display). These problems could get really subtle and insightful — we just need to come up with good illustrative cases.

PHP/forms:
Easier problems could be 142-level, algorithmically-simple problems designed to call attention to the syntactical differences between Java and PHP. Emphasis should probably be on using aspects of the language itself more than on algorithmic problem solving. This might include things like array and string manipulation, looping and if/else blocks, and simple printed output. Moderate problems might produce simple HTML output with if/then blocks and loops, make use of associative arrays and foreach loops, or involve reverse-engineering a program to produce given HTML code. Harder problems might examine and validate parameters, read and write files, output small forms with validation, and produce small web services with HTTP status error codes when certain conditions fail.

DOM/JavaScript:
As with PHP, easier problems should probably be algorithmically-simple problems focused on learning JavaScript itself and illustrating the differences between it, Java, and PHP. This would probably include things like array and string manipulation, printing stuff, etc. Moderate problems might make some small DOM changes, like creating and injecting a couple of elements, attaching event handlers, modifying styles, moving things around, making things appear and disappear, and using loops on a single object (e.g., looping an image animation). Harder problems might involve things like composing a good filtering $$() selector, making obtrusive JavaScript unobtrusive, walking the DOM tree, reading CSS properties before modifying them, and looping across multiple elements.

AJAX/web services:
Easier problems would probably just fetch plain text and inject it directly into the page. Moderate problems might involve creating a few elements to insert into the DOM, and requesting and processing XML (including walking the XML DOM). Harder problems might combine selective use of parameters to a web service, handling HTTP status errors, making a combination of XML and text requests, and list processing with DOM injection of multiple elements (looping).

SQL/tables:
Easier problems will probably be straight SQL, learning to use = and LIKE on a couple of fields in a single table. Moderate problems would probably begin to do JOINs and filtering on both tables, maybe practice normalizing table schemas to eliminate redundancy, and start printing simple query output in HTML tables. Hard problems might involve queries where the order of JOINs and poor matching decisions could result in long query times on large datasets, as well as adding zebra-striping, using parameters in queries, and sanitizing input.