It is important to note that the Copilot is responsible for running contests, but more importantly they are responsible for delivering the "product" to the customer. Many customers will not want to know the details of what contests you are running. In fact, the concept of a contest will not be important to them. They just want their product completed. So, it is the Copilot's responsibility to work with the customer at an appropriate level of detail.

Key Tasks a Copilot Performs

1. Creation of contest specs and management of spec reviews.
2. Setup and launch contests
3. Monitor/Manage contests as they are in progress, including questions in the forums, issuing VM's, etc.
4. Testing the final submissions
5. Merging the final submission into the main application branch and validating that the code works on a VM.
6. Working with the customer team to meet deployment schedules

General Information

Copilots will self-select for projects from the following page: Active Copilot Opportunities

The opportunities vary in scope and disciplines. Openings can be for an entire project from Conceptualization through Deployment. Others can be for an assembly or small set of two or three components or a prototype conversion. The predominant task for all Copilot positions is execution of the TopCoder Methodology as it relates to the successful completion of the project.

Communication with Project Stakeholders

All projects have stakeholders who have an interest in the status and outcome of the project. Communication of contest status and planning is achieved by creating and updating a TopCoder "Game Plan" which will be visible to Stakeholders.

A Game Plan is TopCoder's version of a project plan. However, instead of tracking individual tasks and dependencies it summarizes what contests will be run, when the contests will be run and how much the contests will cost.

• Example Game Plan

• Game Plan Template

Game Plans are created during project initiation and continually updated to reflect any changes. Every contest can impact timelines so the GamePlan should be adjusted on a regular basis. Certain contest deliverables (such as System Architecture) necessitate a re-evaluation of the scope and type of contests. The Copilot will be responsible for both creating Game Plans and refactoring them as a project progresses.

Once the initial game plan is agreed upon, the Copilot should load all known contests into http://www.topcoder.com/direct and link any dependent contests. This will keep everyone one updated on the plan and project status.

Contest Preparation

Copilot are responsible for the contest specification and contest launch.

Contest Specification

Every competition will have its own requirements and every competition type will have standard (required and optional) inputs and outputs. The Copilot must ensure their scheduled contest has a completed specification. Copilots must sign off on the specification as having met corresponding review requirements. For details, refer to each contest type in the TopCoder Methodology.

Contest Launch

Copilots are responsible for ensuring a contest is launched successfully and in a timely manner. You will use http://www.topcoder.com/direct to create and manage contests.

The following items are required before a contest can launch, usually in this order.

• Client approval - the client has signed off on the project.
• Pricing approval - either the project has the default pricing for its type or the customer has approved the change in pricing.
• Specification - a complete competition specification has been entered into the wiki.
• Passed spec review - the competition specification has passed review. This should be 24 hours prior to the scheduled launch time.
• Dependent competitions - the competition has no dependencies or all dependencies are satisfied.

Contest Management

Contest Management Rules and Guidelines For the latest rules and guidelines in managing contests in the Online Review, please read Generic Managing Competitions document.

Contest Health

Copilots should monitor their contests and check registration to make sure participation is appropriate and be prepared to react to improve the success of a contest.

Forum Questions

Copilots are responsible for monitoring forums and answering questions as needed. Depending on the project and contest, the Copilot may be the main resource handling forum questions or they may not need to answer questions at all, such as in the case of a component development with no appeals to the manager. However, Copilots should always monitor the forums to make sure a contest is on track.

Reviews

Copilots are expected to work with reviewers to ensure the review/appeal/final fix phases of a contest run smoothly.

Manager Appeals

Copilots are expected to handle any manager appeals. For example, if a competitor disputes a reviewer's score.

Post-Mortem Review

If a contest fails (e.g. due to no submissions or if all submissions fail review) Copilots are responsible to analyze the reasons of the failure and fill out the Post-Mortem scorecard.

Support from Contest Completion to Delivery

The TopCoder methodology is unique, but borrows many pieces from standard SDLC phases. To achieve project success build cycles must go through testing (certification) and acceptance, deployment and eventually maintenance. Deliverables from each contest must also go through these phases (as required) and it's the Community Platform Managers job to make sure contest deliverables and artifacts are smoothly handed off to the customer. Here are some tools that TopCoder provides to make management easy on a Copilot:

• Bug Races: To manage change requests and resolve issues, Bug Races should be used. This contest type was created specifically to support virtualization of project updates and fixes. For example, these are used when testing uncovers issues with application code.
• Build: A build team at TopCoder ensures any component can be properly built and test cases executed. For example, after your component completes final review, the build team is assigned the task to build the component. They report any issues to make sure winning competitors fix any issues with components.
• Integration: Catalog components are built and tested nightly so any breakages can be found early. Similarly, continuous integration should be used on the application level to support upcoming build cycles and addition of component dependencies.
• Deployment: Cloud servers are available for every project so that an entire development or testing environment can be made available in minutes. For example, the client needs to sign off on a functioning part of the application or bug races need to be run on a project in testing.

Projects and Copilots should strive to automate continuous integration, build, testing and deployment as much and as early in the project as possible. Not only does this support virtualization of the project for subsequent contests, but it allows the customer to see real progress and provide direction.

How are Copilots Paid?

Copilots are paid by TopCoder. Typical engagements have payments structured on a per contest basis. Payments for each contest are triggered upon the successful completion of each contest. Each Copilot opportunity should specify the specific payment terms if they differ from the default.

Here are the default payment rates per contest type.