I built a comment moderation system for a site with 50k new posts a month where each post could have N comments.
Our approach was to use flag for moderation buttons near each post and on each comment, which executed an ajax call to the moderation backend and notified the user of the action. In the backend, moderators had access to two separate lists displaying all flagged posts and comments.
The idea here was that moderators would want to take action on posts and comments separately due to their nature (posts could incite flagged comments, for instance). The list was sorted by number of times an item had been flagged so mods could easily see where strange things were happening, as users of the site were generally quick to mass-flag posts if things were taking a bad turn.
Per item, mods could quickly see the full content of the post by hovering over it, as well as clicking an icon to head directly to the post in context (because sometimes it's not immediately clear if something is offensive without it). They could quickly spam, trash, or temporarily hide the post from that list as well, and later on we built links that allowed them to head directly to the profile of the user who posted it to see that user's post history, which helped them make decisions. From that profile page they could also IP ban the user, although we didn't recommend doing that since IP bans are little more than a stopgap solution. (We intended to build a sandbox system where return offenders were boxed into their own version of the site where their comments were still appearing, though no other users could see them, but we didn't get around to implementing it).
Since the moderation system had multiple moderators, it was important for moderators to know who was doing what, so they weren't working the same posts. To that end we had a very simple option where mods could indicate they were working with an item, which would merely indicate in a highlight to other mods that that item was currently being inspected. When taking significant action, for instance IP banning or deleting, mods were required to write a note about why they were taking that action so that if it needed to be reverted or something else needed to happen, all mods would know what was going on.
Finally, the frontend of the site added controls for mods to post pages when they were logged in so they didn't have to click back and forth between the backend and the site all the time if they encountered something while simply browsing. This was implemented as a request by the mods after the system had been live for a while, and was pretty instrumental in maintaining moderator happiness ;).
So, key takeaways from this system:
- Posts that need attention are flagged by users
- Flagged posts are sorted by number of 'votes'
- Each flagged post has actions: in-context view, spam/trash/hide, etc.
- Posts and comments are separated into different lists
- Mods can assign items to themselves so other mods know not to go there
- IP bans don't really work, build a sandbox if you have time
- Require mods to communicate with each other by adding notes to actions they take
- Make it really easy to use so mods can quickly go through several items in a single session
- Support rudimentary controls in the frontend
Hope that helps. We had a lot of fun figuring out this system. FWIW, the website I'm talking about is Buurtlink (in Dutch), which is a community site where you enter your postcode and see posts in your geographical area. It has 700k users and over 2M posts over 2 years since launch.
Oh, as for patterns - the above was designed in part by looking at how most major forum software handles moderation, as well as blog software like Wordpress, which by now has become pretty proficient at offering an easy to use UI. We also looked at spam control in email software like Gmail and Thunderbird. All of this was combined with a lot of common sense and the specific needs of our moderation team, as well as the business goals of the client (not much budget to have moderators spend a lot of time doing moderation, for instance).
