diff --git a/client/package.json b/client/package.json
index 7bb93451..859e958d 100644
--- a/client/package.json
+++ b/client/package.json
@@ -3,6 +3,7 @@
   "version": "0.1.0",
   "private": true,
   "dependencies": {
+    "cross-env": "^10.1.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "react-scripts": "5.0.1"
@@ -13,7 +14,7 @@
     "typescript": "^4.9.5"
   },
   "scripts": {
-    "start": "PORT=3004 react-scripts start",
+    "start": "cross-env PORT=3004 react-scripts start",
     "build": "react-scripts build",
     "test": "react-scripts test",
     "eject": "react-scripts eject"
@@ -36,4 +37,4 @@
       "last 1 safari version"
     ]
   }
-}
\ No newline at end of file
+}
diff --git a/client/src/components/Evaluations.tsx b/client/src/components/Evaluations.tsx
index 1b992a1d..52f620c4 100644
--- a/client/src/components/Evaluations.tsx
+++ b/client/src/components/Evaluations.tsx
@@ -4,6 +4,7 @@ import ClassService from '../services/ClassService';
 import EnrollmentService from '../services/EnrollmentService';
 
 import { ImportGradeComponent } from './ImportGrade';
+import InfoButton from './InfoButton';
 
 interface EvaluationsProps {
   onError: (errorMessage: string) => void;
@@ -21,7 +22,7 @@ const Evaluations: React.FC<EvaluationsProps> = ({ onError }) => {
   // Predefined evaluation goals
   const evaluationGoals = [
     'Requirements',
-    'Configuration Management', 
+    'Configuration Management',
     'Project Management',
     'Design',
     'Tests',
@@ -40,6 +41,17 @@ const Evaluations: React.FC<EvaluationsProps> = ({ onError }) => {
     }
   }, [onError]);
 
+  const [discrepancies, setDiscrepancies] = useState<any[]>([]);
+
+  const loadDiscrepancies = useCallback(async (classId: string) => {
+    try {
+      const data = await EnrollmentService.getDiscrepancys(classId);
+      setDiscrepancies(data);
+    } catch (error) {
+      onError(`Failed to load discrepancies: ${(error as Error).message}`);
+    }
+  }, [onError]);
+
   // Load all classes on component mount
   useEffect(() => {
     loadClasses();
@@ -50,10 +62,11 @@ const Evaluations: React.FC<EvaluationsProps> = ({ onError }) => {
     if (selectedClassId) {
       const classObj = classes.find(c => c.id === selectedClassId);
       setSelectedClass(classObj || null);
+      loadDiscrepancies(selectedClassId); // CARREGAR DISCREPÂNCIAS QUANDO A TURMA É SELECIONADA
     } else {
       setSelectedClass(null);
     }
-  }, [selectedClassId, classes]);
+  }, [selectedClassId, classes, loadDiscrepancies]);
 
   const handleClassSelection = (classId: string) => {
     setSelectedClassId(classId);
@@ -75,6 +88,7 @@ const Evaluations: React.FC<EvaluationsProps> = ({ onError }) => {
       await EnrollmentService.updateEvaluation(selectedClass.id, studentCPF, goal, grade);
       // Reload classes to get updated enrollment data
       await loadClasses();
+      await loadDiscrepancies(selectedClass.id); // RECARREGAR DISCREPÂNCIAS QUANDO UMA NOTA É ALTERADA
     } catch (error) {
       onError(`Failed to update evaluation: ${(error as Error).message}`);
     }
@@ -94,7 +108,7 @@ const Evaluations: React.FC<EvaluationsProps> = ({ onError }) => {
   return (
     <div className="evaluation-section">
       <h3>Evaluations</h3>
-      
+
       {/* Class Selection */}
       <div className="class-selection-container">
         <label htmlFor="classSelect">Select Class:</label>
@@ -114,10 +128,10 @@ const Evaluations: React.FC<EvaluationsProps> = ({ onError }) => {
       </div>
 
       {!selectedClass && (
-        <div style={{ 
-          padding: '20px', 
-          border: '2px dashed #ccc', 
-          borderRadius: '8px', 
+        <div style={{
+          padding: '20px',
+          border: '2px dashed #ccc',
+          borderRadius: '8px',
           textAlign: 'center',
           color: '#666',
           marginTop: '20px'
@@ -128,10 +142,10 @@ const Evaluations: React.FC<EvaluationsProps> = ({ onError }) => {
       )}
 
       {selectedClass && selectedClass.enrollments.length === 0 && (
-        <div style={{ 
-          padding: '20px', 
-          border: '2px dashed #ccc', 
-          borderRadius: '8px', 
+        <div style={{
+          padding: '20px',
+          border: '2px dashed #ccc',
+          borderRadius: '8px',
           textAlign: 'center',
           color: '#666',
           marginTop: '20px'
@@ -149,7 +163,7 @@ const Evaluations: React.FC<EvaluationsProps> = ({ onError }) => {
             <ImportGradeComponent classID={selectedClassId} />
           </div>
           <h4>{selectedClass.topic} ({selectedClass.year}/{selectedClass.semester})</h4>
-          
+
           <div className="evaluation-matrix">
             <table className="evaluation-table">
               <thead>
@@ -163,19 +177,28 @@ const Evaluations: React.FC<EvaluationsProps> = ({ onError }) => {
               <tbody>
                 {selectedClass.enrollments.map(enrollment => {
                   const student = enrollment.student;
-                  
+
                   // Create a map of evaluations for quick lookup
                   const studentEvaluations = enrollment.evaluations.reduce((acc, evaluation) => {
                     acc[evaluation.goal] = evaluation.grade;
                     return acc;
-                  }, {} as {[goal: string]: string});
+                  }, {} as { [goal: string]: string });
 
                   return (
                     <tr key={student.cpf} className="student-row">
-                      <td className="student-name-cell">{student.name}</td>
+                      <td className="student-name-cell">{student.name}
+                        { }
+                        {(() => {
+                          const disc = discrepancies.find(d => d.studentCPF === student.cpf);
+                          if (disc) {
+                            <InfoButton text={`Discrepância: ${disc.DiscrepancyCount.toFixed(2)}`} />
+                          }
+                          return null;
+                        })()}
+                      </td>
                       {evaluationGoals.map(goal => {
                         const currentGrade = studentEvaluations[goal] || '';
-                        
+
                         return (
                           <td key={goal} className="evaluation-cell">
                             <select
diff --git a/client/src/components/InfoButton.tsx b/client/src/components/InfoButton.tsx
new file mode 100644
index 00000000..f70f24be
--- /dev/null
+++ b/client/src/components/InfoButton.tsx
@@ -0,0 +1,60 @@
+import React, { useState } from "react";
+
+type InfoButtonProps = {
+    text: string;
+};
+
+const InfoButton: React.FC<InfoButtonProps> = ({ text }) => {
+    const [show, setShow] = useState(false);
+
+    return (
+        <div style={{ position: "relative", display: "inline-block", marginLeft: "4px" }}>
+            <div
+                onMouseEnter={() => setShow(true)}
+                onMouseLeave={() => setShow(false)}
+                style={{
+                    width: "16px",
+                    height: "16px",
+                    cursor: "pointer",
+                    display: "flex",
+                    alignItems: "center",
+                    justifyContent: "center",
+                }}
+            >
+                <svg
+                    width="14"
+                    height="14"
+                    viewBox="0 0 24 24"
+                    fill="#555"
+                    style={{ display: "block" }}
+                >
+                    <circle cx="12" cy="12" r="10" stroke="#555" strokeWidth="2" fill="none" />
+                    <line x1="12" y1="10" x2="12" y2="16" stroke="#555" strokeWidth="2" />
+                    <circle cx="12" cy="7" r="1.5" fill="#555" />
+                </svg>
+            </div>
+
+            {show && (
+                <div
+                    style={{
+                        position: "absolute",
+                        top: "-35px",
+                        left: "0",
+                        background: "#333",
+                        color: "white",
+                        padding: "6px 8px",
+                        fontSize: "11px",
+                        borderRadius: "4px",
+                        whiteSpace: "nowrap",
+                        boxShadow: "0px 2px 6px rgba(0,0,0,0.25)",
+                        zIndex: 999,
+                    }}
+                >
+                    {text}
+                </div>
+            )}
+        </div>
+    );
+};
+
+export default InfoButton;
diff --git a/client/src/services/EnrollmentService.ts b/client/src/services/EnrollmentService.ts
index d073a9bf..0902ed4d 100644
--- a/client/src/services/EnrollmentService.ts
+++ b/client/src/services/EnrollmentService.ts
@@ -78,6 +78,20 @@ class EnrollmentService {
       throw error;
     }
   }
+
+  static async getDiscrepancys(classId: string): Promise<any[]> {
+    try {
+      const response = await fetch(`${API_BASE_URL}/api/classes/${classId}/discrepancys`);  
+      if (!response.ok) {
+        throw new Error('Failed to fetch discrepancies');
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      console.error('Error fetching discrepancies:', error);
+      throw error;
+    }
+  }
 }
 
 export default EnrollmentService;
\ No newline at end of file
diff --git a/server/src/models/Classes.ts b/server/src/models/Classes.ts
index b51640ed..747bd7d8 100644
--- a/server/src/models/Classes.ts
+++ b/server/src/models/Classes.ts
@@ -1,4 +1,5 @@
 import { Class } from './Class';
+import { Enrollment } from './Enrollment';
 import { Student } from './Student';
 
 export class Classes {
@@ -31,6 +32,17 @@ export class Classes {
     return true;
   }
 
+  // Merge evaluations and self-evaluations from one enrollment to another
+  private mergeEnrollmentsData(from: Enrollment, to: Enrollment): void {
+    from.getEvaluations().forEach(evaluation => 
+      to.addOrUpdateEvaluation(evaluation.getGoal(), evaluation.getGrade())
+    );
+    
+    from.getSelfEvaluations().forEach(selfEvaluation => 
+      to.addOrUpdateSelfEvaluation(selfEvaluation.getGoal(), selfEvaluation.getGrade())
+    );
+  }
+
   // Update class
   updateClass(updatedClass: Class): Class {
     const existingClass = this.findClassById(updatedClass.getClassId());
@@ -54,22 +66,16 @@ export class Classes {
       const existingEnrollment = existingClass.findEnrollmentByStudentCPF(studentCPF);
       
       if (existingEnrollment) {
-        // Update existing enrollment's evaluations
-        const updatedEvaluations = updatedEnrollment.getEvaluations();
-        updatedEvaluations.forEach(evaluation => {
-          existingEnrollment.addOrUpdateEvaluation(evaluation.getGoal(), evaluation.getGrade());
-        });
+        // Update existing enrollment's evaluations and self-evaluations
+        this.mergeEnrollmentsData(updatedEnrollment, existingEnrollment);
       } else {
         // Add new enrollment that doesn't exist yet
         try {
           existingClass.addEnrollment(updatedEnrollment.getStudent());
           const newEnrollment = existingClass.findEnrollmentByStudentCPF(studentCPF);
           if (newEnrollment) {
-            // Copy over evaluations from updated enrollment
-            const updatedEvaluations = updatedEnrollment.getEvaluations();
-            updatedEvaluations.forEach(evaluation => {
-              newEnrollment.addOrUpdateEvaluation(evaluation.getGoal(), evaluation.getGrade());
-            });
+            // Copy over evaluations and self-evaluations from updated enrollment
+            this.mergeEnrollmentsData(updatedEnrollment, newEnrollment);
           }
         } catch (error) {
           // Enrollment already exists, this shouldn't happen but handle gracefully
diff --git a/server/src/models/Enrollment.ts b/server/src/models/Enrollment.ts
index f13a0e94..cc34d4f8 100644
--- a/server/src/models/Enrollment.ts
+++ b/server/src/models/Enrollment.ts
@@ -1,18 +1,20 @@
 import { Student } from './Student';
-import { Evaluation } from './Evaluation';
+import { Evaluation, Grade } from './Evaluation';
 
 export class Enrollment {
   private student: Student;
   private evaluations: Evaluation[];
+  private selfEvaluations: Evaluation[];
   // Média do estudante antes da prova final
   private mediaPreFinal: number;
   // Média do estudante depois da final
   private mediaPosFinal: number;
   private reprovadoPorFalta: Boolean;
 
-  constructor(student: Student, evaluations: Evaluation[] = [], mediaPreFinal: number = 0, mediaPosFinal: number = 0, reprovadoPorFalta: Boolean = false) {
+  constructor(student: Student, evaluations: Evaluation[] = [], selfEvaluations: Evaluation[] = [], mediaPreFinal: number = 0, mediaPosFinal: number = 0, reprovadoPorFalta: Boolean = false) {
     this.student = student;
     this.evaluations = evaluations;
+    this.selfEvaluations = selfEvaluations;
     this.mediaPreFinal = mediaPreFinal;
     this.mediaPosFinal = mediaPosFinal;
     this.reprovadoPorFalta = reprovadoPorFalta;
@@ -23,11 +25,6 @@ export class Enrollment {
     return this.student;
   }
 
-  // Get evaluations
-  getEvaluations(): Evaluation[] {
-    return [...this.evaluations]; // Return copy to prevent external modification
-  }
-
   // Get media do estudante antes da prova final
   getMediaPreFinal(): number{
     return this.mediaPreFinal;
@@ -58,45 +55,101 @@ export class Enrollment {
     this.reprovadoPorFalta = reprovadoPorFalta;
   }
 
+  private clone(list: Evaluation[]): Evaluation[] {
+    return [...list];
+  }
+
   // Add or update an evaluation
-  addOrUpdateEvaluation(goal: string, grade: 'MANA' | 'MPA' | 'MA'): void {
-    const existingIndex = this.evaluations.findIndex(evaluation => evaluation.getGoal() === goal);
+  private addOrUpdateIn(list: Evaluation[], goal: string, grade: Grade): void {
+    const existingIndex = list.findIndex(evaluation => evaluation.getGoal() === goal);
     if (existingIndex >= 0) {
-      this.evaluations[existingIndex].setGrade(grade);
+      list[existingIndex].setGrade(grade);
     } else {
-      this.evaluations.push(new Evaluation(goal, grade));
+      list.push(new Evaluation(goal, grade));
     }
   }
 
   // Remove an evaluation
-  removeEvaluation(goal: string): boolean {
-    const existingIndex = this.evaluations.findIndex(evaluation => evaluation.getGoal() === goal);
+  private removeFrom(list: Evaluation[], goal: string): boolean {
+    const existingIndex = list.findIndex(evaluation => evaluation.getGoal() === goal);
     if (existingIndex >= 0) {
-      this.evaluations.splice(existingIndex, 1);
+      list.splice(existingIndex, 1);
       return true;
     }
     return false;
   }
 
+  private findIn(list: Evaluation[], goal: string): Evaluation | undefined {
+    return list.find(evaluation => evaluation.getGoal() === goal);
+  }
+
+  getEvaluations(): Evaluation[] {
+    return this.clone(this.evaluations); // Return copy to prevent external modification
+  }
+
+  getSelfEvaluations(): Evaluation[] {
+    return this.clone(this.selfEvaluations); // Return copy to prevent external modification
+  }
+
+  // Add or update an evaluation
+  addOrUpdateEvaluation(goal: string, grade: Grade): void {
+    this.addOrUpdateIn(this.evaluations, goal, grade);
+  }
+  
+  // Add or update a self-evaluation
+  addOrUpdateSelfEvaluation(goal: string, grade: Grade): void {
+    this.addOrUpdateIn(this.selfEvaluations, goal, grade);
+  }
+
+  // Remove an evaluation
+  removeEvaluation(goal: string): boolean {
+    return this.removeFrom(this.evaluations, goal);
+  }
+
+  // Remove a self-evaluation
+  removeSelfEvaluation(goal: string): boolean {
+    return this.removeFrom(this.selfEvaluations, goal);
+  }
+  
   // Get evaluation for a specific goal
   getEvaluationForGoal(goal: string): Evaluation | undefined {
-    return this.evaluations.find(evaluation => evaluation.getGoal() === goal);
+    return this.findIn(this.evaluations, goal);
+  }
+
+  // Get self-evaluation for a specific goal
+  getSelfEvaluationForGoal(goal: string): Evaluation | undefined {
+    return this.findIn(this.selfEvaluations, goal);
   }
 
   // Convert to JSON for API responses
   toJSON() {
     return {
       student: this.student.toJSON(),
-      evaluations: this.evaluations.map(evaluation => evaluation.toJSON())
+      evaluations: this.evaluations.map(evaluation => evaluation.toJSON()),
+      selfEvaluations: this.selfEvaluations.map(selfEvaluation => selfEvaluation.toJSON())
     };
   }
 
   // Create Enrollment from JSON object
-  static fromJSON(data: { student: any; evaluations: any[] }, student: Student): Enrollment {
+  static fromJSON(data: { student: any; evaluations: any[]; selfEvaluations: any[] }, student: Student): Enrollment {
     const evaluations = data.evaluations
       ? data.evaluations.map((evalData: any) => Evaluation.fromJSON(evalData))
       : [];
-    
-    return new Enrollment(student, evaluations);
+    const selfEvaluations = data.selfEvaluations
+      ? data.selfEvaluations.map((evalData: any) => Evaluation.fromJSON(evalData))
+      : [];
+    return new Enrollment(student, evaluations, selfEvaluations);
   }
-}
+
+  discrepancy(): number {
+    let discrepancyCount = 0;   
+    this.evaluations.forEach(evaluation => {
+      const selfEvaluation = this.getSelfEvaluationForGoal(evaluation.getGoal());
+      if (selfEvaluation && (selfEvaluation.getGrade() !== evaluation.getGrade()) && (evaluation.getGrade() !== 'MA') && (selfEvaluation.getGrade() !== 'MANA')) {
+          discrepancyCount++;
+      }
+    });
+    return discrepancyCount/this.evaluations.length;
+  } 
+
+}
\ No newline at end of file
diff --git a/server/src/server.ts b/server/src/server.ts
index 6e2597b3..e01a7f08 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -451,4 +451,23 @@ app.post('/api/classes/gradeImport/:classId', upload_dir.single('file'), async (
 
 app.listen(PORT, () => {
   console.log(`Server running on http://localhost:${PORT}`);
+});
+
+// get discrepancy count between evaluations and self-evaluations
+app.get('/api/classes/:classId/discrepancys', (req: Request, res: Response) => {
+  try {
+    const { classId } = req.params; 
+    const classObj = classes.findClassById(classId);
+    if (!classObj) {
+      return res.status(404).json({ error: 'Class not found' });
+    }
+    const discrepancies = classObj.getEnrollments().map(enrollment => ({
+      studentCPF: enrollment.getStudent().getCPF(),
+      studentName: enrollment.getStudent().name,
+      discrepancyCount: enrollment.discrepancy()
+    })).filter(item => item.discrepancyCount > 0);
+    res.json(discrepancies);
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to fetch discrepancies' });
+  }
 });
\ No newline at end of file