diff --git a/package.json b/package.json
index 37f66f78cbed369f51f01c858c2c9eb87d2f9fc5..d16bedaea13436f7587b643d9db4448bd379df37 100644
--- a/package.json
+++ b/package.json
@@ -14,7 +14,7 @@
     "build": "nest build",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
     "start": "nest start",
-    "start:dev": "nest start --watch",
+    "start:dev": "cross-env NODE_ENV=dev nest start --watch",
     "start:debug": "nest start --debug --watch",
     "start:prod": "node dist/main",
     "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
@@ -47,6 +47,7 @@
     "@types/supertest": "^2.0.11",
     "@typescript-eslint/eslint-plugin": "^5.0.0",
     "@typescript-eslint/parser": "^5.0.0",
+    "cross-env": "^7.0.3",
     "eslint": "^8.0.1",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-prettier": "^4.0.0",
diff --git a/src/app.module.ts b/src/app.module.ts
index 83454b396fbe455e342ac10495c8d9d035e20455..525febf15237651fc7a66eddfdf9b53f1d73a9ef 100644
--- a/src/app.module.ts
+++ b/src/app.module.ts
@@ -3,8 +3,14 @@ import { MongooseModule } from '@nestjs/mongoose';
 import { mongodb } from './config';
 import { PeopleModule } from './people/people.module';
 import { GroupsModule } from './groups/groups.module';
+import { InternshipsModule } from './internships/internships.module';
 
 @Module({
-  imports: [PeopleModule, GroupsModule, MongooseModule.forRoot(mongodb.uri)],
+  imports: [
+    PeopleModule,
+    GroupsModule,
+    InternshipsModule,
+    MongooseModule.forRoot(mongodb.uri),
+  ],
 })
 export class AppModule {}
diff --git a/src/internships/dao/internships.dao.ts b/src/internships/dao/internships.dao.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c42a2b4b5de08f784faec0ea37fb196abe64edaf
--- /dev/null
+++ b/src/internships/dao/internships.dao.ts
@@ -0,0 +1,81 @@
+import {
+  Injectable,
+  NotFoundException,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { CreateInternshipDto } from '../dto/create-internship.dto';
+import { InternshipDto } from '../dto/internship.dto';
+import { TrackingDto } from '../dto/nested-create/tracking.dto';
+import { Internship } from '../schemas/internship.schema';
+
+@Injectable()
+export class InternshipDao {
+  constructor(
+    @InjectModel(Internship.name)
+    private readonly _groupModel: Model<Internship>,
+  ) {}
+
+  find = (): Promise<Internship[]> =>
+    new Promise((resolve, reject) => {
+      this._groupModel.find({}, {}, {}, (err, value) => {
+        if (err) reject(err.message);
+        if (!value) reject('No values');
+        resolve(value);
+      });
+    });
+
+  findByStudentId = (studentId: string): Promise<Internship | void> =>
+    new Promise((resolve, reject) => {
+      this._groupModel.findOne({ studentId }, {}, {}, (err, value) => {
+        if (err) reject(err.message);
+        if (!value) reject(new NotFoundException());
+        resolve(value);
+      });
+    });
+
+  save = (internship: CreateInternshipDto): Promise<Internship> =>
+    new Promise((resolve, reject) => {
+      // do smth
+      const _internship: InternshipDto = {
+        ...internship,
+        tracking: {
+          state: 'state-1',
+          status: 'pending',
+        },
+      };
+      new this._groupModel(_internship).save((err, value) => {
+        if (err) reject(err.message);
+        if (!value) reject(new InternalServerErrorException());
+        resolve(value);
+      });
+    });
+
+  findByStudentIdAndUpdate = (
+    studentId: string,
+    internship: InternshipDto,
+  ): Promise<Internship | void> =>
+    new Promise((resolve, reject) => {
+      this._groupModel.findOneAndReplace(
+        { studentId },
+        internship,
+        {
+          new: true,
+          runValidators: true,
+        },
+        (err, value) => {
+          if (err) reject(err.message);
+          resolve(value);
+        },
+      );
+    });
+
+  findByStudentIdAndRemove = (studentId: string): Promise<Internship | void> =>
+    new Promise((resolve, reject) => {
+      this._groupModel.findOneAndDelete({ studentId }, {}, (err) => {
+        if (err) reject(err.message);
+        resolve();
+      });
+    });
+}
diff --git a/src/internships/dto/create-internship.dto.ts b/src/internships/dto/create-internship.dto.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6dfd532639f2585cadad5af3b26cfa1229409b4e
--- /dev/null
+++ b/src/internships/dto/create-internship.dto.ts
@@ -0,0 +1,21 @@
+import { Type } from 'class-transformer';
+import {
+  IsString,
+  IsNotEmpty,
+  IsDefined,
+  IsNotEmptyObject,
+  ValidateNested,
+} from 'class-validator';
+import { InformationDto } from './nested-create/information.dto';
+
+export class CreateInternshipDto {
+  @IsString()
+  @IsNotEmpty()
+  studentId: string;
+
+  @IsDefined()
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => InformationDto)
+  information: InformationDto;
+}
diff --git a/src/internships/dto/internship.dto.ts b/src/internships/dto/internship.dto.ts
new file mode 100644
index 0000000000000000000000000000000000000000..331dab3b43342f45a236beffa26b442dd065daf2
--- /dev/null
+++ b/src/internships/dto/internship.dto.ts
@@ -0,0 +1,28 @@
+import { Type } from 'class-transformer';
+import {
+  IsString,
+  IsNotEmpty,
+  IsDefined,
+  IsNotEmptyObject,
+  ValidateNested,
+} from 'class-validator';
+import { InformationDto } from './nested-create/information.dto';
+import { TrackingDto } from './nested-create/tracking.dto';
+
+export class InternshipDto {
+  @IsString()
+  @IsNotEmpty()
+  studentId: string;
+
+  @IsDefined()
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => InformationDto)
+  information: InformationDto;
+
+  @IsDefined()
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => TrackingDto)
+  tracking: TrackingDto;
+}
diff --git a/src/internships/dto/nested-create/address.dto.ts b/src/internships/dto/nested-create/address.dto.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2003cff4b9bf6ec508b5683873aa76061f690536
--- /dev/null
+++ b/src/internships/dto/nested-create/address.dto.ts
@@ -0,0 +1,19 @@
+import { IsString, IsNotEmpty } from 'class-validator';
+
+export class AddressDto {
+  @IsString()
+  @IsNotEmpty()
+  street: string;
+
+  @IsString()
+  @IsNotEmpty()
+  city: string;
+
+  @IsString()
+  @IsNotEmpty()
+  postalCode: string;
+
+  @IsString()
+  @IsNotEmpty()
+  country: string;
+}
diff --git a/src/internships/dto/nested-create/affectation.dto.ts b/src/internships/dto/nested-create/affectation.dto.ts
new file mode 100644
index 0000000000000000000000000000000000000000..12cfca04b744870b086079d9ae0e8c3ed94299c9
--- /dev/null
+++ b/src/internships/dto/nested-create/affectation.dto.ts
@@ -0,0 +1,46 @@
+import { Type } from 'class-transformer';
+import {
+  IsString,
+  IsNotEmpty,
+  IsDateString,
+  IsDefined,
+  IsNotEmptyObject,
+  ValidateNested,
+} from 'class-validator';
+import { AddressDto } from './address.dto';
+
+export class AffectationDto {
+  @IsString()
+  @IsNotEmpty()
+  service: string;
+
+  @IsString()
+  @IsNotEmpty()
+  responsibleName: string;
+
+  @IsString()
+  @IsNotEmpty()
+  responsibleEmail: string;
+
+  @IsString()
+  @IsNotEmpty()
+  responsiblePhone: string;
+
+  @IsString()
+  @IsNotEmpty()
+  responsibleFunction: string;
+
+  @IsDateString()
+  @IsNotEmpty()
+  dateStart: Date;
+
+  @IsDateString()
+  @IsNotEmpty()
+  dateEnd: Date;
+
+  @IsDefined()
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => AddressDto)
+  address: AddressDto;
+}
diff --git a/src/internships/dto/nested-create/company.dto.ts b/src/internships/dto/nested-create/company.dto.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fee0c5915d3d43bb30d6a4fc07fd0762fed64add
--- /dev/null
+++ b/src/internships/dto/nested-create/company.dto.ts
@@ -0,0 +1,33 @@
+import { Type } from 'class-transformer';
+import {
+  IsString,
+  IsNotEmpty,
+  IsDefined,
+  IsNotEmptyObject,
+  ValidateNested,
+} from 'class-validator';
+import { AddressDto } from './address.dto';
+
+export class CompanyDto {
+  @IsString()
+  @IsNotEmpty()
+  ceoName: string;
+
+  @IsString()
+  @IsNotEmpty()
+  companyName: string;
+
+  @IsString()
+  @IsNotEmpty()
+  hrContactName: string;
+
+  @IsString()
+  @IsNotEmpty()
+  hrContactEmail: string;
+
+  @IsDefined()
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => AddressDto)
+  address: AddressDto;
+}
diff --git a/src/internships/dto/nested-create/compensation.dto.ts b/src/internships/dto/nested-create/compensation.dto.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5e403bcb411ca1cfbf635e88b51fddaff5dde1d1
--- /dev/null
+++ b/src/internships/dto/nested-create/compensation.dto.ts
@@ -0,0 +1,15 @@
+import { IsString, IsNotEmpty } from 'class-validator';
+
+export class CompensationDto {
+  @IsString()
+  @IsNotEmpty()
+  gratificationAmount: string;
+
+  @IsString()
+  @IsNotEmpty()
+  modalities: string;
+
+  @IsString()
+  @IsNotEmpty()
+  othersAdvantages: string;
+}
diff --git a/src/internships/dto/nested-create/information.dto.ts b/src/internships/dto/nested-create/information.dto.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7a281404a7cca139e9c1a6a05e7b2c68aead6c20
--- /dev/null
+++ b/src/internships/dto/nested-create/information.dto.ts
@@ -0,0 +1,42 @@
+import { Type } from 'class-transformer';
+import {
+  IsString,
+  IsNotEmpty,
+  IsDefined,
+  IsNotEmptyObject,
+  ValidateNested,
+} from 'class-validator';
+import { AffectationDto } from './affectation.dto';
+import { CompanyDto } from './company.dto';
+import { CompensationDto } from './compensation.dto';
+import { StudentDto } from './student.dto';
+
+export class InformationDto {
+  @IsDefined()
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => StudentDto)
+  student: StudentDto;
+
+  @IsDefined()
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => CompanyDto)
+  company: CompanyDto;
+
+  @IsDefined()
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => AffectationDto)
+  affectation: AffectationDto;
+
+  @IsDefined()
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => CompensationDto)
+  compensation: CompensationDto;
+
+  @IsString()
+  @IsNotEmpty()
+  internshipDescription: string;
+}
diff --git a/src/internships/dto/nested-create/student.dto.ts b/src/internships/dto/nested-create/student.dto.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0d8d8cd599c55ca0f2ae42bc56ecf339dfdb6611
--- /dev/null
+++ b/src/internships/dto/nested-create/student.dto.ts
@@ -0,0 +1,48 @@
+import { Type } from 'class-transformer';
+import {
+  IsString,
+  IsNotEmpty,
+  IsDateString,
+  IsDefined,
+  IsNotEmptyObject,
+  ValidateNested,
+  IsEmail,
+  IsAlphanumeric,
+  IsPhoneNumber,
+} from 'class-validator';
+import { AddressDto } from './address.dto';
+
+export class StudentDto {
+  @IsString()
+  @IsNotEmpty()
+  completeName: string;
+
+  @IsString()
+  @IsPhoneNumber()
+  @IsNotEmpty()
+  phone: string;
+
+  @IsDateString()
+  @IsNotEmpty()
+  birthDate: Date;
+
+  @IsDefined()
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => AddressDto)
+  address: AddressDto;
+
+  @IsString()
+  @IsNotEmpty()
+  FormationAndSpecialty: string;
+
+  @IsString()
+  @IsEmail()
+  @IsNotEmpty()
+  email: string;
+
+  @IsString()
+  @IsAlphanumeric()
+  @IsNotEmpty()
+  socialSecurityNumber: string;
+}
diff --git a/src/internships/dto/nested-create/tracking.dto.ts b/src/internships/dto/nested-create/tracking.dto.ts
new file mode 100644
index 0000000000000000000000000000000000000000..05f9a83d48a3d2495e4b1675b4509fdc8ca3f717
--- /dev/null
+++ b/src/internships/dto/nested-create/tracking.dto.ts
@@ -0,0 +1,11 @@
+import { IsString, IsNotEmpty } from 'class-validator';
+
+export class TrackingDto {
+  @IsString()
+  @IsNotEmpty()
+  status: string;
+
+  @IsString()
+  @IsNotEmpty()
+  state: string;
+}
diff --git a/src/internships/entities/internship.entity.ts b/src/internships/entities/internship.entity.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b886cc449fac2399d41b1b011627aeaea9dbcc1d
--- /dev/null
+++ b/src/internships/entities/internship.entity.ts
@@ -0,0 +1,12 @@
+import { InformationEntity } from './nested-entities/information.entity';
+import { TrackingEntity } from './nested-entities/tracking.entity';
+
+export class InternshipEntity {
+  studentId: string;
+  information: InformationEntity;
+  tracking: TrackingEntity;
+
+  constructor(partial: Partial<InternshipEntity>) {
+    Object.assign(this, partial);
+  }
+}
diff --git a/src/internships/entities/nested-entities/address.entity.ts b/src/internships/entities/nested-entities/address.entity.ts
new file mode 100644
index 0000000000000000000000000000000000000000..db6ba95b81eb088e8faf2b82b30582c206ef98b5
--- /dev/null
+++ b/src/internships/entities/nested-entities/address.entity.ts
@@ -0,0 +1,10 @@
+export class AddressEntity {
+  street: string;
+  postalCode: string;
+  city: string;
+  country: string;
+
+  constructor(partial: Partial<AddressEntity>) {
+    Object.assign(this, partial);
+  }
+}
diff --git a/src/internships/entities/nested-entities/affectation.entity.ts b/src/internships/entities/nested-entities/affectation.entity.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d1bf6198fbc5a8a2f310d6e781951f25d6910967
--- /dev/null
+++ b/src/internships/entities/nested-entities/affectation.entity.ts
@@ -0,0 +1,16 @@
+import { AddressEntity } from './address.entity';
+
+export class AffectationEntity {
+  service: string;
+  responsibleName: string;
+  responsibleEmail: string;
+  responsiblePhone: string;
+  responsibleFunction: string;
+  dateStart: Date;
+  dateEnd: Date;
+  address: AddressEntity;
+
+  constructor(partial: Partial<AffectationEntity>) {
+    Object.assign(this, partial);
+  }
+}
diff --git a/src/internships/entities/nested-entities/company.entity.ts b/src/internships/entities/nested-entities/company.entity.ts
new file mode 100644
index 0000000000000000000000000000000000000000..25c356128140b3d6e9b0797205041c8d829f6fd3
--- /dev/null
+++ b/src/internships/entities/nested-entities/company.entity.ts
@@ -0,0 +1,13 @@
+import { AddressEntity } from './address.entity';
+
+export class CompanyEntity {
+  ceoName: string;
+  companyName: string;
+  hrContactName: string;
+  hrContactEmail: string;
+  address: AddressEntity;
+
+  constructor(partial: Partial<CompanyEntity>) {
+    Object.assign(this, partial);
+  }
+}
diff --git a/src/internships/entities/nested-entities/compensation.entity.ts b/src/internships/entities/nested-entities/compensation.entity.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d097a14c49929233a258caccd34e4e36f1420776
--- /dev/null
+++ b/src/internships/entities/nested-entities/compensation.entity.ts
@@ -0,0 +1,9 @@
+export class CompensationEntity {
+  gratificationAmount: string;
+  modalities: string;
+  othersAdvantages: string;
+
+  constructor(partial: Partial<CompensationEntity>) {
+    Object.assign(this, partial);
+  }
+}
diff --git a/src/internships/entities/nested-entities/information.entity.ts b/src/internships/entities/nested-entities/information.entity.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4ecba28640ae894c0790d2d776896b51f05cc47b
--- /dev/null
+++ b/src/internships/entities/nested-entities/information.entity.ts
@@ -0,0 +1,16 @@
+import { AffectationEntity } from './affectation.entity';
+import { CompanyEntity } from './company.entity';
+import { CompensationEntity } from './compensation.entity';
+import { StudentEntity } from './student.entity';
+
+export class InformationEntity {
+  student: StudentEntity;
+  company: CompanyEntity;
+  affectation: AffectationEntity;
+  compensation: CompensationEntity;
+  internshipDescription: string;
+
+  constructor(partial: Partial<InformationEntity>) {
+    Object.assign(this, partial);
+  }
+}
diff --git a/src/internships/entities/nested-entities/student.entity.ts b/src/internships/entities/nested-entities/student.entity.ts
new file mode 100644
index 0000000000000000000000000000000000000000..780f7e90b06beea495573b9b3ee4928196d41eae
--- /dev/null
+++ b/src/internships/entities/nested-entities/student.entity.ts
@@ -0,0 +1,15 @@
+import { AddressEntity } from './address.entity';
+
+export class StudentEntity {
+  completeName: string;
+  phone: string;
+  birthDate: Date;
+  address: AddressEntity;
+  FormationAndSpecialty: string;
+  email: string;
+  socialSecurityNumber: string;
+
+  constructor(partial: Partial<StudentEntity>) {
+    Object.assign(this, partial);
+  }
+}
diff --git a/src/internships/entities/nested-entities/tracking.entity.ts b/src/internships/entities/nested-entities/tracking.entity.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6838aeb5c32621f9b3206e5e55e18b24f9c00f34
--- /dev/null
+++ b/src/internships/entities/nested-entities/tracking.entity.ts
@@ -0,0 +1,8 @@
+export class TrackingEntity {
+  status: string;
+  state: string;
+
+  constructor(partial: Partial<TrackingEntity>) {
+    Object.assign(this, partial);
+  }
+}
diff --git a/src/internships/internships.controller.ts b/src/internships/internships.controller.ts
new file mode 100644
index 0000000000000000000000000000000000000000..066e877930fafcad2dca42c1fdc1d4a3fd5d6d7d
--- /dev/null
+++ b/src/internships/internships.controller.ts
@@ -0,0 +1,55 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Put,
+  Delete,
+  Param,
+  Body,
+  UseInterceptors,
+} from '@nestjs/common';
+import { HttpInterceptor } from '../interceptors/http.interceptor';
+import { CreateInternshipDto } from './dto/create-internship.dto';
+import { InternshipDto } from './dto/internship.dto';
+import { InternshipEntity } from './entities/internship.entity';
+import { InternshipService } from './internships.service';
+
+@Controller('internships')
+@UseInterceptors(HttpInterceptor)
+export class InternshipsController {
+  constructor(private readonly _groupsService: InternshipService) {}
+
+  @Get()
+  findAll(): Promise<InternshipEntity[] | void> {
+    return this._groupsService.findAll();
+  }
+
+  @Get(':studentId')
+  findOne(
+    @Param() params: { studentId: string },
+  ): Promise<InternshipEntity | void> {
+    return this._groupsService.findOne(params.studentId);
+  }
+
+  @Post()
+  create(
+    @Body() internshipDto: CreateInternshipDto,
+  ): Promise<InternshipEntity> {
+    return this._groupsService.create(internshipDto);
+  }
+
+  @Put(':studentId')
+  update(
+    @Param() params: { studentId: string },
+    @Body() internshipDto: InternshipDto,
+  ): Promise<InternshipEntity | void> {
+    return this._groupsService.update(params.studentId, internshipDto);
+  }
+
+  @Delete(':studentId')
+  delete(
+    @Param() params: { studentId: string },
+  ): Promise<InternshipEntity | void> {
+    return this._groupsService.delete(params.studentId);
+  }
+}
diff --git a/src/internships/internships.module.ts b/src/internships/internships.module.ts
new file mode 100644
index 0000000000000000000000000000000000000000..50a8cd3c8c49446f6fc31ba9563e30912593ef72
--- /dev/null
+++ b/src/internships/internships.module.ts
@@ -0,0 +1,17 @@
+import { Module, Logger } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { InternshipDao } from './dao/internships.dao';
+import { InternshipsController } from './internships.controller';
+import { InternshipService } from './internships.service';
+import { Internship, InternshipSchema } from './schemas/internship.schema';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([
+      { name: Internship.name, schema: InternshipSchema },
+    ]),
+  ],
+  controllers: [InternshipsController],
+  providers: [InternshipService, InternshipDao, Logger],
+})
+export class InternshipsModule {}
diff --git a/src/internships/internships.service.ts b/src/internships/internships.service.ts
new file mode 100644
index 0000000000000000000000000000000000000000..89d8f0830f442b99cb91102fbba4bb02c3c71bb6
--- /dev/null
+++ b/src/internships/internships.service.ts
@@ -0,0 +1,28 @@
+import { Injectable } from '@nestjs/common';
+import { InternshipDao } from './dao/internships.dao';
+import { CreateInternshipDto } from './dto/create-internship.dto';
+import { InternshipDto } from './dto/internship.dto';
+import { InternshipEntity } from './entities/internship.entity';
+
+@Injectable()
+export class InternshipService {
+  constructor(private readonly _internshipsDao: InternshipDao) {}
+
+  findAll = (): Promise<InternshipEntity[] | void> =>
+    this._internshipsDao.find();
+
+  findOne = (studentId: string): Promise<InternshipEntity | void> =>
+    this._internshipsDao.findByStudentId(studentId);
+
+  create = (internship: CreateInternshipDto): Promise<InternshipEntity> =>
+    this._internshipsDao.save(internship);
+
+  update = (
+    studentId: string,
+    internship: InternshipDto,
+  ): Promise<InternshipEntity | void> =>
+    this._internshipsDao.findByStudentIdAndUpdate(studentId, internship);
+
+  delete = (studentId: string): Promise<InternshipEntity | void> =>
+    this._internshipsDao.findByStudentIdAndRemove(studentId);
+}
diff --git a/src/internships/schemas/internship.schema.ts b/src/internships/schemas/internship.schema.ts
new file mode 100644
index 0000000000000000000000000000000000000000..aa4557cb097c775c791f396ee86a68a91c0159ef
--- /dev/null
+++ b/src/internships/schemas/internship.schema.ts
@@ -0,0 +1,29 @@
+import { Document } from 'mongoose';
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import {
+  Information,
+  InformationSchema,
+} from './nested-schemas/information.schema';
+import { Tracking, TrackingSchema } from './nested-schemas/tracking.schema';
+export type InternshipDocument = Internship & Document;
+
+@Schema({
+  toJSON: {
+    virtuals: true,
+    transform: (doc: any, ret: any) => {
+      delete ret._id;
+    },
+  },
+})
+export class Internship {
+  @Prop({ type: String, required: true, trim: true })
+  studentId: string;
+
+  @Prop({ type: InformationSchema, required: true, trim: true })
+  information: Information;
+
+  @Prop({ type: TrackingSchema, required: true, trim: true })
+  tracking: Tracking;
+}
+
+export const InternshipSchema = SchemaFactory.createForClass(Internship);
diff --git a/src/internships/schemas/nested-schemas/address.schema.ts b/src/internships/schemas/nested-schemas/address.schema.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9563cde8b62bb5cab17d88ebd60ea7ee08d654c4
--- /dev/null
+++ b/src/internships/schemas/nested-schemas/address.schema.ts
@@ -0,0 +1,19 @@
+import { Document } from 'mongoose';
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+
+// Nested Schema
+@Schema({ _id: false })
+export class Address extends Document {
+  @Prop({ type: String, required: true, trim: true })
+  street: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  postalCode: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  city: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  country: string;
+}
+export const AddressSchema = SchemaFactory.createForClass(Address);
diff --git a/src/internships/schemas/nested-schemas/affectation.schema.ts b/src/internships/schemas/nested-schemas/affectation.schema.ts
new file mode 100644
index 0000000000000000000000000000000000000000..23301160ae336f8fbffdb06e5f0ccd1e3f47a06c
--- /dev/null
+++ b/src/internships/schemas/nested-schemas/affectation.schema.ts
@@ -0,0 +1,32 @@
+import { Document } from 'mongoose';
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { Address, AddressSchema } from './address.schema';
+
+// Nested Schema
+@Schema({ _id: false })
+export class Affectation extends Document {
+  @Prop({ type: String, required: true, trim: true })
+  service: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  responsibleName: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  responsibleEmail: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  responsiblePhone: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  responsibleFunction: string;
+
+  @Prop({ type: Date, required: true, trim: true })
+  dateStart: Date;
+
+  @Prop({ type: Date, required: true, trim: true })
+  dateEnd: Date;
+
+  @Prop({ type: AddressSchema, required: true, trim: true })
+  address: Address;
+}
+export const AffectationSchema = SchemaFactory.createForClass(Affectation);
diff --git a/src/internships/schemas/nested-schemas/company.schema.ts b/src/internships/schemas/nested-schemas/company.schema.ts
new file mode 100644
index 0000000000000000000000000000000000000000..20fb49ae90f80d8fd8581f5bcc074f3a5977daad
--- /dev/null
+++ b/src/internships/schemas/nested-schemas/company.schema.ts
@@ -0,0 +1,23 @@
+import { Document } from 'mongoose';
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { Address, AddressSchema } from './address.schema';
+
+// Nested Schema
+@Schema({ _id: false })
+export class Company extends Document {
+  @Prop({ type: String, required: true, trim: true })
+  ceoName: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  companyName: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  hrContactName: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  hrContactEmail: string;
+
+  @Prop({ type: AddressSchema, required: true, trim: true })
+  address: Address;
+}
+export const CompanySchema = SchemaFactory.createForClass(Company);
diff --git a/src/internships/schemas/nested-schemas/compensation.schema.ts b/src/internships/schemas/nested-schemas/compensation.schema.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2e6d8b721abedd79c32c38faf377be503f15b64b
--- /dev/null
+++ b/src/internships/schemas/nested-schemas/compensation.schema.ts
@@ -0,0 +1,16 @@
+import { Document } from 'mongoose';
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+
+// Nested Schema
+@Schema({ _id: false })
+export class Compensation extends Document {
+  @Prop({ type: String, required: true, trim: true })
+  gratificationAmount: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  modalities: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  othersAdvantages: string;
+}
+export const CompensationSchema = SchemaFactory.createForClass(Compensation);
diff --git a/src/internships/schemas/nested-schemas/information.schema.ts b/src/internships/schemas/nested-schemas/information.schema.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bb8df63efb4c6c948d088b21566fe6e9075f77c5
--- /dev/null
+++ b/src/internships/schemas/nested-schemas/information.schema.ts
@@ -0,0 +1,26 @@
+import { Document } from 'mongoose';
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { Student, StudentSchema } from './Student.schema';
+import { Company, CompanySchema } from './company.schema';
+import { Affectation, AffectationSchema } from './affectation.schema';
+import { Compensation, CompensationSchema } from './compensation.schema';
+
+// Nested Schema
+@Schema({ _id: false })
+export class Information extends Document {
+  @Prop({ type: StudentSchema, required: true, trim: true })
+  student: Student;
+
+  @Prop({ type: CompanySchema, required: true, trim: true })
+  company: Company;
+
+  @Prop({ type: AffectationSchema, required: true, trim: true })
+  affectation: Affectation;
+
+  @Prop({ type: CompensationSchema, required: true, trim: true })
+  compensation: Compensation;
+
+  @Prop({ type: String, required: true, trim: true })
+  internshipDescription: string;
+}
+export const InformationSchema = SchemaFactory.createForClass(Information);
diff --git a/src/internships/schemas/nested-schemas/student.schema.ts b/src/internships/schemas/nested-schemas/student.schema.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f25a3fbf5730ba62320bad9d49bdb5c60bd95e4f
--- /dev/null
+++ b/src/internships/schemas/nested-schemas/student.schema.ts
@@ -0,0 +1,29 @@
+import { Document } from 'mongoose';
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { Address, AddressSchema } from './address.schema';
+
+// Nested Schema
+@Schema({ _id: false })
+export class Student extends Document {
+  @Prop({ type: String, required: true, trim: true })
+  completeName: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  phone: string;
+
+  @Prop({ type: Date, required: true, trim: true })
+  birthDate: Date;
+
+  @Prop({ type: AddressSchema, required: true, trim: true })
+  address: Address;
+
+  @Prop({ type: String, required: true, trim: true })
+  FormationAndSpecialty: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  email: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  socialSecurityNumber: string;
+}
+export const StudentSchema = SchemaFactory.createForClass(Student);
diff --git a/src/internships/schemas/nested-schemas/tracking.schema.ts b/src/internships/schemas/nested-schemas/tracking.schema.ts
new file mode 100644
index 0000000000000000000000000000000000000000..95ce881cb47b0b9fcfde0b7a6ee14ee62fc86e50
--- /dev/null
+++ b/src/internships/schemas/nested-schemas/tracking.schema.ts
@@ -0,0 +1,13 @@
+import { Document } from 'mongoose';
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+
+// Nested Schema
+@Schema({ _id: false })
+export class Tracking extends Document {
+  @Prop({ type: String, required: true, trim: true })
+  status: string;
+
+  @Prop({ type: String, required: true, trim: true })
+  state: string;
+}
+export const TrackingSchema = SchemaFactory.createForClass(Tracking);
diff --git a/src/main.ts b/src/main.ts
index bf7f9ff096122e86e38387baf5d7b80092794f7b..d8f8ddbbdd561fb76405dc4998154d4a185dad08 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -5,6 +5,12 @@ import { server } from './config';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
+  const env = process.env.NODE_ENV;
+  if (env === 'dev') {
+    app.enableCors();
+  } else {
+    // enableCors for SPECIFIC origin only, aka the way it's supposed to be
+  }
   await app.useGlobalPipes(
     new ValidationPipe({
       whitelist: true,
@@ -13,4 +19,4 @@ async function bootstrap() {
   );
   await app.listen(server.port);
 }
-bootstrap();
\ No newline at end of file
+bootstrap();