Minutes
Audio Player
Policies
<p><strong>Procedure Sexual Harassment of Students Prohibited</strong></p><p>&nbsp;</p><p>The procedure is intended to set forth the requirements of Policy 3205, including the process for a prompt, thorough, and equitable investigation of allegations of sexual harassment and the need to take appropriate steps to resolve such situations. If sexual harassment is found to have created a hostile environment, staff must take immediate action to eliminate the harassment, prevent its reoccurrence, and address its effects.</p><p>&nbsp;</p><p>This procedure applies to sexual harassment (including sexual violence) targeted at students carried out by other students, employees or third parties involved in school District activities. Because students can experience the continuing effects of off-campus harassment in the educational setting, the District will consider the effects of off-campus conduct when evaluating whether there is a hostile environment on campus. The District has jurisdiction over these complaints pursuant to Title IX of the Education Amendments of 1972, Chapter 28A.640, RCW and Chapter 392-190 WAC.</p><p>&nbsp;</p><p><strong>Title IX Coordinator, Investigator, and Decision-maker</strong></p><p>&nbsp;</p><p><strong>The District will designate and authorize one employee to act as “Title IX Coordinator” to coordinate the District’s state and federal sex discrimination and sexual harassment regulation compliance efforts.</strong> The decision-maker who reaches the final determination of responsibility for alleged Title IX sexual harassment will be the Superintendent or designee. The decision-maker cannot be the same person who serves as the Title IX Coordinator or the investigator of the Title IX complaint.</p><p>&nbsp;</p><p>The Title IX coordinator’s name, title, office address, telephone number, and email address must be available on the district website; in handbooks/catalogs that are made available to staff, students, and parents; and in the district’s nondiscrimination statement.</p><p>&nbsp;</p><p>Any individual designated as Title IX Coordinator, an investigator, or decision-maker, and any person who facilitates an informal resolution process must not have a conflict of interest or bias for or against the individual(s) who made the complaint (“complainant(s)”) or the individual(s) reported to be the perpetrator of the conduct that could constitute sexual harassment (“respondent(s)”) in general or individually, and must receive training on the following:</p><ul><li>The definition of sexual harassment under Title IX and state law;</li><li>The scope of the District’s education program or activity;</li><li>How to conduct an investigation and grievance process and informal resolution process;</li><li>How to serve impartially;</li><li>Their responsibilities chapter WAC 392-190 WAC; and</li><li>How to raise awareness of and eliminate bias based on sex, race, creed, religion, color, national origin, honorably discharged veteran or military status, sexual orientation, gender expression, gender identity, the presence of any sensory, mental or physical disability, or the use of a trained dog guide or service animal.</li></ul><p>&nbsp;</p><p>District investigators must also receive training on issues of relevance to create an investigative report that fairly summarizes relevant evidence.</p><p>&nbsp;</p><p>District decision-makers must also receive training on any technology to be used during hearings if the District provides for a hearing, and on issues of relevance of questions and evidence, including the requirement that questions and evidence about a complainant’s sexual predisposition or prior sexual conduct are not relevant unless 1) such questions and evidence is offered to prove that someone other than the respondent committed the alleged conduct or 2) questions and evidence concerning specific incidents of the complainant’s prior sexual behavior with respect to the respondent is offered to prove consent.</p><p>&nbsp;</p><p>Any training materials used to train Title IX Coordinators, investigators, decision-makers, and any person who facilitates an informal resolution process must not rely on sex stereotypes and must promote impartial investigations and adjudications of complaints. The District shall maintain for a period of seven years records of any informal resolution and the result; and all materials used to train Title IX Coordinators, investigators, decision-makers, and any person who facilitates an informal resolution process, and make such materials available on the District’s website.</p><p>&nbsp;</p><p><strong>Notice of Sexual Harassment Policy and Procedure</strong></p><ul><li>Information about the District’s sexual harassment policy and complaint procedure will be easily understandable and conspicuously posted throughout each school building, be reproduced in each student, staff, volunteer, and parent handbook. Upon request, this notice will be provided in a language that each parent and guardian can understand.</li><li>In addition to the posting and reproduction of this procedure and Policy 3205, the District will provide annual notice to employees that complaints pursuant to this procedure may be filed at Lake Washington School District Resource Center: 16250 NE 74th St. Redmond, WA 98052.</li></ul><p>&nbsp;</p><p><strong>Responding to Notice of Sexual Harassment</strong></p><p>The District is on notice and required to take action when any employee knows, or in the exercise of reasonable care should know, about possible sexual harassment. This includes informal and formal reports made to any staff member.</p><p>&nbsp;</p><p>Upon notice of possible sexual harassment, staff will always notify the Title IX Coordinator. In addition, in the event of an alleged sexual assault, the school principal will immediately inform law enforcement andChild Protective Services consistent with procedure 3241P notify the targeted student(s) and their parents/guardians of their right to file a criminal complaint and a sexual harassment complaint simultaneously.</p><p>&nbsp;</p><ul><li>Once the District will inform the complainant and their parent/guardian how to report any subsequent problems. Additionally, the District will conduct follow-up inquiries to see if there have been any new incidents or instances of retaliation, and to promptly respond and appropriately address continuing or new problems. Follow-up inquiries will follow a timeline agreed to by the District and complainant.</li></ul><p>&nbsp;</p><p>A complainant may file a formal complaint at any time while receiving supportive measures. A complainant, their parent or guardian, or the Title IX Coordinator may file a formal complaint because, for example, they feel the complaint needs to be more thoroughly investigated or discipline may be warranted for individual alleged to have engaged in sexually harassing conduct.</p><p>&nbsp;</p><p><strong>Confidentiality</strong></p><ul><li>The District will maintain as confidential any supportive measures provided to the complainant or respondent, to the extent that maintaining such confidentiality would not impair the ability of the district to provide the supportive measures.</li><li>If a complainant requests that his or her name not be revealed to the alleged perpetrator or asks that the District not investigate or seek action against the alleged perpetrator, the request will be forwarded to the Title IX Coordinator for evaluation.</li><li>The Title IX Coordinator should inform the complainant that honoring the request may limit its ability to respond fully to the incident, including pursuing disciplinary action against the alleged perpetrator.</li><li>If the complainant still requests that his or her name not be disclosed to the alleged perpetrator or that the District not investigate or seek action against the alleged perpetrator, the District will need to determine whether or not it can honor such a request while still providing a safe and nondiscriminatory environment for all students, staff, and other third parties engaging in District activities, including the person who reported the sexual harassment. Although a complainant’s request to have his or her name withheld may limit the District’s ability to respond fully to an individual allegation of sexual harassment, the District will use other appropriate means available to address the sexual harassment.</li></ul><p>&nbsp;</p><p><strong>Retaliation</strong></p><p>Title IX and state law prohibit retaliation against any individual who files a complaint under these laws or participates in a complaint investigation. When an informal or formal complaint of sexual harassment is made, the District will take steps to stop further harassment and prevent any retaliation against the person who made the complaint, was the subject of the harassment, or against those who provided information as a witness. The District will investigate all allegations of retaliation and take actions against those found to have retaliated.</p><p>&nbsp;</p><p>&nbsp;</p><p><strong>Formal Complaint Process</strong></p><p>&nbsp;</p><p><strong>Level One – Complaint to District</strong></p><p>Anyone may initiate a formal complaint of sexual harassment, even if the informal complaint process is being utilized.</p><p>&nbsp;</p><p><strong>Filing of Complaint</strong></p><ul><li>All formal complaints will be in writing and will set forth the specific acts, conditions or circumstances alleged to have occurred and to constitute sexual harassment. The Title IX Coordinator may draft the complaint based on the report of the complainant for the complainant to review and approve. The Title IX Coordinator may also conclude that the District needs to conduct an investigation based on information in his or her possession, regardless of the complainant's interest in filing a formal complaint.</li></ul><ul><li>The time period for filing a complaint is one year from the date of the occurrence that is the subject matter of the complaint. However, a complaint filing deadline may not be imposed if the complainant was prevented from filing due to: 1) Specific misrepresentations by the District that it had resolved the problem forming the basis of the complaint; or 2) Withholding of information that the District was required to provide under WAC 392-190-065 or WAC 392-190-005.</li><li>Complaints may be submitted by mail, fax, e-mail or hand-delivery to the District Title IX Coordinator. Any District employee who receives a complaint that meets these criteria will promptly notify the Coordinator. &nbsp;</li></ul><p>&nbsp;</p><p><strong>Determining Whether to Incorporate Additional Title IX Complaint Procedures</strong></p><p>The Title IX Coordinator will assess whether a formal complaint of sexual harassment meets the criteria for a Title IX complaint. If so, the District will implement investigation and response procedures under state law, as well as the following additional procedures as required by Title IX regulations.</p><p>&nbsp;</p><p>Under Title IX, the term “sexual harassment” means:</p><ul><li>an employee of the District conditioning the provision of an aid, benefit, or service on an individual’s participation in unwelcome sexual conduct;</li><li>conduct that creates a “hostile environment,” meaning unwelcome conduct determined by a reasonable person to be so severe, pervasive, and objectively offensive that it effectively denies a person equal access to the education program or activity; or</li><li>“sexual assault,” as defined in 20 U.S.C. 1092(f)(6)(A)(v), “dating violence” as defined in 34 U.S.C. 12291(a)(10), “domestic violence” as defined in 34 U.S.C. 12291(a)(8), or “stalking” as defined in 34 U.S.C. 12291(a)(30).</li></ul><p>&nbsp;</p><p>The District will implement additional Title IX procedures in response to a sexual harassment complaint when the alleged conduct constitutes sexual harassment as defined by Title IX regulations, and:</p><ul><li>The written complaint is filed by the complainant of the alleged sexual harassment, by the complainant’s legal guardian, or by the Title IX Coordinator;</li><li>The complaint requests that the District investigate the allegation(s) of sexual harassment, as defined under Title IX regulations;</li><li>The complaint is against a named respondent who, at the time of the alleged harassment, was under the control of the school District (such as a student, employee, or volunteer);</li><li>The alleged sexually harassing conduct occurred in the United States; and</li><li>The complainant is participating in or attempting to participate in the District’s educational program or activity at the time.</li></ul><p>&nbsp;</p><p>If the formal complaint is determined to meet the criteria for a Title IX complaint, the District will conduct the investigation implementing the additional Title IX procedures. <strong>Skip to <em>Standard Complaint Process with Additional Title IX Requirements.</em></strong></p><p>&nbsp;</p><p>If the formal complaint is determined not to meet the criteria for a Title IX complaint, the District will conduct the investigation without implementing the additional Title IX procedures. <strong>Continue to <em>Standard Complaint Process. </em></strong></p><p><strong>&nbsp;</strong></p><p><strong>STANDARD COMPLAINT PROCESS </strong></p><p><strong>&nbsp;</strong></p><p><strong>Acknowledging a Complaint - <em>Standard Complaint Process</em></strong></p><ul><li>Upon receipt of a complaint, the Coordinator will provide the complainant a copy of this procedure in a language the complainant can understand.</li></ul><p>&nbsp;</p><p><strong>Investigating a Formal Complaint - <em>Standard Complaint Process</em></strong></p><ul><li>Investigations will be carried out in a manner that is prompt, thorough, reliable, and impartial. During the investigation process, the complainant and respondent(s), if the complainant has identified an accused harasser(s), will have an equal opportunity to present witnesses and relevant evidence. Complainants, respondents, and witnesses may have a trusted adult with them during any district-initiated investigatory activities. The school district and complainant may also agree to resolve the complaint in lieu of an investigation.</li><li>When the investigation is completed, the investigator will compile a full written report of the complaint and the results of the investigation.</li></ul><p>&nbsp;</p><p><strong>Mediation - <em>Standard Complaint Process</em></strong></p><p>At any time during the complaint procedure set forth in WAC 392-190-065 through 392-190-075, a District may, at its own expense, offer mediation. The complainant and the District may agree to extend the complaint process deadlines in order to pursue mediation.</p><p>&nbsp;</p><p>The purpose of mediation is to provide both the complainant and the district an opportunity to resolve disputes and reach a mutually acceptable agreement through the use of an impartial mediator. Mediation must be voluntary and requires the mutual agreement of both parties. It may be terminated by either party at any time during the mediation process. It may not be used to deny or delay a complainant’s right to utilize the complaint procedures.</p><p>&nbsp;</p><p>Mediation must be conducted by a qualified and impartial mediator who may not:</p><p>1) Be an employee of any school district, public charter school, or other public or private agency that is providing education related services to a student who is the subject of the complaint being mediated; or 2) Have a personal or professional conflict of interest. A mediator is not considered an employee of the district or charter school or other public or private agency solely because he or she serves as a mediator.</p><p>&nbsp;</p><p>If the parties reach agreement through mediation, they may execute a legally binding agreement that sets forth the resolution and states that all discussions that occurred during the course of mediation will remain confidential and may not be used as evidence in any subsequent complaint, due process hearing or civil proceeding. The agreement must be signed by the complainant and a district representative who has authority to bind the District.</p><p>&nbsp;</p><p><strong>Superintendent’s Response to a Formal Complaint - <em>Standard Complaint Process</em></strong></p><ul><li>The superintendent or their designee will respond in writing to the complainant and the respondent within thirty (30) calendar days of receipt of the complaint, unless otherwise agreed to by the complainant or if exceptional circumstances related to the complaint require an extension of the time limit. In the event an extension is needed, the District will notify the parties in writing of the reason for the extension and the anticipated response date. At the time the District responds to the complainant, the District must send a copy of the response to the office of the superintendent of public instruction.</li><li>The response of the superintendent or designee will include: 1) a summary of the results of the investigation; 2) a statement as to whether a preponderance of the evidence establishes that the complainant was sexually harassed; 3) if sexual harassment is found to have occurred, the corrective measures the district deems necessary, including assurance that the district will take steps to prevent recurrence and remedy its effects on the complainant and others, if appropriate; 4) notice of the complainant’s right to appeal to the school board and the necessary filing information; and 5) any corrective measures the district will take, remedies for the complainant (e.g., sources of counseling, advocacy and academic support), and notice of potential sanctions for the perpetrator(s) (e.g., discipline).</li><li>The superintendent’s or designee’s response will be provided in a language the complainant can understand and may require language assistance for complainants with limited English proficiency in accordance with Title VI of the Civil Rights Act of 1964. If the complaint alleges discriminatory harassment by a named respondent or respondent(s), the coordinator will provide the respondent(s) with notice of the outcome of the investigation and notice of their right to appeal any discipline or corrective action imposed by the district.</li><li>Any corrective measures deemed necessary will be instituted as quickly as possible, but in no event more than thirty (30) days after the superintendent's mailing of a written response, unless the accused is appealing the imposition of discipline and the district is barred by due process considerations or a lawful order from imposing the discipline until the appeal process is concluded. Staff may also pursue complaints through the appropriate collective bargaining agreement process or anti-discrimination policy.</li><li>The district will inform the complainant and their parent/guardian how to report any subsequent problems. Additionally, the district will conduct follow-up inquiries to see if there have been any new incidents or instances of retaliation, and to promptly respond and appropriately address continuing or new problems. Follow-up inquiries will follow a timeline agreed to by the district and complainant.</li></ul><p>&nbsp;</p><p><strong>Resume “Standard Complaint Process” at Level Two - Appeal to Board of Directors.</strong></p><p>&nbsp;&nbsp;</p><p><strong>STANDARD COMPLAINT PROCESS WITH ADDITIONAL TITLE IX REQUIREMENTS</strong></p><p>The following sections outline the process the district will take to respond to complaints of sexual harassment under state law and Title IX.</p><p>&nbsp;</p><p><strong>Acknowledging a Formal Title IX Complaint</strong></p><p>The Title IX Coordinator will receive and investigate all formal, written complaints of sexual harassment or information in the coordinator’s possession that they believe requires further investigation. The Coordinator will delegate his or her authority to participate in this process if such action is necessary to avoid any potential conflicts of interest. Upon receipt of a complaint, the Coordinator will offer supportive measures to both parties.</p><p>&nbsp;</p><p>The District will acknowledge receipt of the formal complaint by providing the following written notice to the respondent(s) and complainant:</p><ul><li>A copy of the school's discrimination complaint procedure in a language the parties can understand.</li><li>Notice of the allegations of sexual harassment with sufficient time for the parties to prepare a response before any initial interview and with sufficient detail. Such sufficient detail includes the identities of the parties involved in the incident if known, the conduct allegedly constituting sexual harassment, and the date and location of the alleged incident if known.</li><li>Notice that the parties may have an advisor of their choice who may be an attorney or non-attorney, and who may inspect and review evidence of the alleged sexual harassment.</li><li>Notice that the respondent is presumed not responsible for the alleged conduct and that a determination regarding responsibility for alleged sexual harassment is made at the conclusion of the grievance process.</li><li>Notice of any provision in student conduct policies and procedures that prohibits false statements or submitting false information.</li></ul><p>&nbsp;</p><p><strong>Investigation of a Title IX Formal Complaint</strong></p><p>The District must investigate allegations contained in a formal complaint. If the conduct alleged would not constitute sexual harassment under Title IX regulations even if proved, did not occur in the District’s education program or activity, or did not occur against a person in the United States, then the District must dismiss the formal complaint under Title IX. Such dismissal does not preclude action under another provision of District policy or procedure or under sexual harassment investigation procedures as required by state law (See Standard Complaint Process).</p><p>&nbsp;</p><p>The District adopts preponderance of the evidence as the standard or proof it will use in reaching decisions regarding complaints.</p><p>&nbsp;</p><p>The District’s investigation of a Title IX complaint must:</p><ul><li>Include a prompt and thorough investigation into the allegations in the complaint.</li><li>Ensure that the District bears the burden of proof and the burden of gathering evidence sufficient to reach a determination regarding responsibility for the alleged sexual harassment. The District may not access, consider, disclose, or otherwise use a party’s records that are made or maintained by a physician, psychiatrist, psychologist, or other recognized professional or paraprofessional acting or assisting in their professional capacity and made and maintained in connection with the provision of treatment to the party unless the District obtains the party’s voluntary, written consent to do so.</li><li>Provide an equal opportunity for the parties to present witnesses, including fact and expert witnesses, and other inculpatory and exculpatory evidence;</li><li>Not restrict the ability of either party to discuss the allegations under investigation or to gather and present relevant evidence;</li><li>Provide the parties with the same opportunities to have others present during any grievance proceeding; including the opportunity to be accompanied to any related meeting or proceeding by the advisor of their choice, who may be an attorney or non-attorney. The District will apply any restrictions regarding the extent to which an advisor may participate equally to both parties;</li><li>Provide to a party whose participation is invited or expected written notice of the date, time, location, participants, and purpose of all hearings, interviews, or other meetings, with sufficient time for the parties to prepare to participate;</li><li>Prior to the completion of an investigative report, provide an equal opportunity for the parties to inspect and review any evidence obtained as part of the investigation that is directly related to the allegations raised in the formal complaint so that each party can meaningfully respond to the evidence prior to the conclusion of the investigation. This includes evidence that the District does not intend to rely on in reaching a determination of responsibility for the alleged sexual harassment, regardless of the source of the evidence. The parties will have at least ten (10) days to submit a written response for the investigator to consider prior to completion of the investigative report.</li><li>At least ten (10) days prior to a determination regarding responsibility, create an investigative report that fairly summarizes relevant evidence, and send the investigative report in an electronic or hard copy format to each party and each party’s advisor for their review and written response.</li><li>After transmitting the investigative report to the parties, but before reaching a final determination regarding responsibility, the decision maker must give each party the opportunity to submit written, relevant questions that a party wants asked of any party or witness, provide each party with the answers, and allow for additional, limited follow-up questions from each party. Questions and evidence about the complainant’s sexual predisposition or prior sexual behavior are not relevant unless they are offered to prove that someone other than the respondent committed the conduct alleged by the complainant or unless they concern specific incidents of the complainant’s prior sexual behavior with respect to the respondent and are offered to prove consent. The decision-maker must explain to the party proposing the questions any decision to exclude a question as not relevant.</li></ul><p>&nbsp;</p><p>The District’s Title IX investigative and grievance process is not required to include investigative hearings.</p><p>&nbsp;</p><p><strong>Discipline and Emergency Removals for Alleged Sexual Harassment under Title IX</strong></p><p>A respondent who is accused of sexual harassment under Title IX is presumed not responsible for the alleged conduct until a determination regarding responsibility is made at the conclusion of the grievance process. The District may not impose any disciplinary sanctions, or other actions that are not supportive measures, against the respondent until the District has determined the respondent was responsible for the sexual harassment at the conclusion of the grievance process. &nbsp;</p><p>&nbsp;</p><p>These additional Title IX sexual harassment procedures do not preclude a school district from removing a student from school on an emergency basis consistent with Policy and Procedure 3241 – Student Discipline and the associated student discipline regulations for emergency expulsion.</p><p>&nbsp;</p><p><strong>Title IX Informal Resolution Process</strong></p><p>At any time prior to a determination in a formal Title IX complaint, the District may permit a complainant to waive the formal complaint grievance process in favor of an informal resolution process not involving a full investigation and adjudication, provided that the district obtains the parties’ voluntary, written consent; the District does not offer informal resolution of sexual harassment allegations against a respondent who is an employee of the district, the district provide reasonably prompt time frames for the informal resolution process; and the district provides the parties with written notice disclosing the allegations, the requirements for the informal resolution process, and the circumstances in which the parties would be precluded from continuing with a formal resolution process for the same allegations.</p><p>&nbsp;</p><p>A party has the right to withdraw from the informal resolution process and resume the formal Title IX grievance process at any time prior to agreeing to a resolution. The District may not require the waiver of the right to an investigation and adjudication of formal complaints of sexual harassment under Title IX as a condition of enrollment, employment, or enjoyment of any other right, nor may the district require the parties to participate in an informal resolution process. The District will not offer an information resolution process unless a formal complaint is filed.</p><p>&nbsp;</p><p>Superintendent’s Response to a Formal Title IX Complaint</p><p>At the conclusion of the investigation, the decision-maker (superintendent or designee) must issue a written determination of responsibility regarding the alleged sexual harassment within thirty (30) calendar days of receipt of the completed investigation report, unless otherwise agreed to by the complainant or if exceptional circumstances related to the complaint require an extension of the time limit. In the event an extension is needed, the District will notify the parties in writing of the reason for the extension and the anticipated response date.</p><p>&nbsp;</p><p>The superintendent’s written determination must be issued to the parties simultaneously and must include the following:</p><ul><li>Identification of the allegations potentially constituting sexual harassment under Title IX regulations;</li><li>A description of the procedural steps taken from the time of the District’s receipt of the formal complaint through the determination, including any notifications to the parties, interviews with parties and witnesses, site visits, methods used to gather other evidence, and hearings held;</li><li>Findings supporting the determination;</li><li>A summary of the results of the investigation;</li><li>Conclusions regarding the application of the District’s code of conduct policies to the facts;</li><li>A statement as to whether a preponderance of the evidence establishes that the complainant was sexually harassed;</li><li>A statement of, and rationale for, the result as to each allegation, including a determination regarding responsibility, any disciplinary or other sanctions imposed on the respondent, and whether remedies designed to restore or preserve equal access to the education program or activity will be provided to the complainant; and</li><li>If sexual harassment is found to have occurred, the corrective measures the district deems necessary, including assurance that the district will take steps to prevent recurrence and remedy its effects on the complainant and others, if appropriate; and</li><li>Notice of the parties’ right to appeal to the school board and the necessary filing information.</li></ul><p>&nbsp;</p><p>The superintendent’s or designee’s response will be provided in a language the complainant can understand and may require language assistance for complainants with limited English proficiency in accordance with Title VI of the Civil Rights Act of 1964.</p><p>&nbsp;</p><p>At the time the district responds to the parties, the district must send a copy of the response to the office of the superintendent of public instruction.</p><p>&nbsp;</p><p>Any corrective measures deemed necessary will be instituted as quickly as possible, but in no event more than thirty (30) days after the superintendent's mailing of a written response, unless the accused is appealing the imposition of discipline and the district is barred by due process considerations or a lawful order from imposing the discipline until the appeal process is concluded. Staff may also pursue complaints through the appropriate collective bargaining agreement process or anti-discrimination policy.</p><p>&nbsp;</p><p>Level Two - Appeal to a District-appointed hearing officer</p><p>&nbsp;</p><p><strong>Notice of Appeal and Hearing</strong></p><ul><li>If the complainant or respondent(s) disagrees with the superintendent’s or designee’s written decision, the disagreeing party may appeal the decision by filing a written notice of appeal with the superintendent within ten (10) calendar days following the date upon which the complainant received the response.</li><li>If the complaint involves a named respondent, the District will implement appeal procedures equally for both parties and provide written notice to the other party when an appeal is filed.</li><li>The District will ensure that the decision-maker for the appeal is not the same decision-maker who reached the determination regarding responsibility or dismissal, the investigator, or the Title IX Coordinator;</li><li>The District will ensure that the decision-maker for the appeal has received the training required for decision-makers as required by this procedure.</li><li>The board will ensure that a hearing commences by the twentieth (20th) calendar day following the filing of the written notice of appeal, unless otherwise agreed to by the complainant and the superintendent or for good cause.</li><li>Both parties will be allowed a reasonable, equal opportunity to submit a written statement in support of or challenging the outcome of the initial determination.</li></ul><p>&nbsp;</p><p><strong>Decision on Appeal</strong></p><ul><li>Unless otherwise agreed to by the complainant, the decision maker on appeal will render a written decision within thirty (30) calendar days following the filing of the notice of appeal and provide the complainant with a copy of the decision.</li><li>The written decision will describe the result of the appeal and the rationale for the result.</li><li>The decision will include notice of the complainant’s right to appeal to the Superintendent of Public Instruction and will identify where and to whom the appeal must be filed. The district will send a copy of the appeal decision to the office of the superintendent of public instruction.</li><li>The decision will be provided in a language that the complainant can understand, which may require language assistance for complainants with limited English proficiency in accordance with Title VI of the Civil Rights Act.</li></ul><p>&nbsp;</p><p>Level Three - Complaint to the Superintendent of Public Instruction</p><p>&nbsp;</p><p><strong>Filing of Complaint</strong></p><ul><li>If a complainant disagrees with the decision of the board of directors, or if the district fails to comply with this procedure, the complainant may file a complaint with the superintendent of public instruction.</li><li>A complaint must be received by the Superintendent of Public Instruction on or before the twentieth (20) calendar day following the date upon which the complainant received written notice of the board of directors’ decision, unless the Superintendent of Public Instruction grants an extension for good cause. Complaints may be submitted by mail, fax, electronic mail, or hand delivery.</li><li>A complaint must be in writing and include: 1) A description of the specific acts, conditions or circumstances alleged to violate applicable anti-sexual harassment laws; 2) The name and contact information, including address, of the complainant; 3) The name and address of the district subject to the complaint; 4) A copy of the district’s complaint and appeal decision, if any; and 5) A proposed resolution of the complaint or relief requested. If the allegations regard a specific student, the complaint must also include the name and address of the student, or in the case of a homeless child or youth, contact information.</li></ul><p>&nbsp;</p><p><strong>Investigation, Determination and Corrective Action</strong></p><ul><li>Upon receipt of a complaint, the Office of the Superintendent of Public Instruction may initiate an investigation, which may include conducting an independent on-site review. OSPI may also investigate additional issues related to the complaint that were not included in the initial complaint or appeal to the superintendent or board.</li><li>Following the investigation, OSPI will make an independent determination as to whether the District has failed to comply with RCW 28A.642.010 or Chapter 392-190, WAC and will issue a written decision to the complainant and the District that addresses each allegation in the complaint and any other noncompliance issues it has identified. The written decision will include corrective actions deemed necessary to correct noncompliance and documentation the District must provide to demonstrate that corrective action has been completed.</li><li>All corrective actions must be completed within the timelines established by OSPI in the written decision unless OSPI grants an extension. If timely compliance is not achieved, OSPI may take action including but not limited to referring the District to appropriate state or federal agencies empowered to order compliance.</li></ul><p>&nbsp;</p><p>A complaint may be resolved at any time when, before the completion of the investigation, the District voluntarily agrees to resolve the complaint. OSPI may provide technical assistance and dispute resolution methods to resolve a complaint.</p><p><strong>&nbsp;</strong></p><p><strong>Level Four - Administrative Hearing, State Requirement</strong></p><p>A complainant or school District that desires to appeal the written decision of the Office of the Superintendent of Public Instruction may file a written notice of appeal with OSPI within thirty (30) calendar days following the date of receipt of that office’s written decision. OSPI will co
Library
Agenda