Hello, I'm

Hasibul Hasan Shanto

And

I have over 4+ years of experience as a Software Engineer, with a focus on robust backend development using PHP and Laravel. Competent with both TypeScript and JavaScript. I have produced scalable and effective solutions for a range of platforms by utilizing the Laravel, Vue and Nuxt frameworks. With my extensive background, I can make a major contribution to the development of complex, scalable and useful software solutions.

Code Showcase

< How I code ? />

Following Best Practices

  • Always use the latest version
  • SOLID, DRY & KISS principles
  • Following design patterns & Clean code
  • Repository, Interfaces & Service Class
  • Modular architecture
  • Database Optimization
  • Eloquent with eager loading
  • Follow PSR-2, PSR-4, PSR-12
  • Unit Testing: Jest, Pest
  • Typescript for type safety
  • Composition API
  • Chunking data for heavy tasks
  • web.php
  • Note.php
  • NoteController.php
  • NoteRequest.php
  • note.blade.php
<?php

use Illuminate\Support\Facades\Route;
use App\Http\Controllers\AuthController;
use App\Http\Controllers\NoteController;

Route::get('/', function () {
    return view('index');
});

Route::controller(AuthController::class)->group(function () {
    Route::get('/login', 'login')->name('login');
    Route::post('/authenticate', 'authenticate')->name('authenticate');
    Route::get('/register', 'registerView')->name('register');
    Route::post('/register', 'register')->name('user.register');
    Route::post('/logout', 'logout')->name('logout');
});

Route::name('dashboard.')->prefix('dashboard')->middleware(['auth'])->group(function () {
    Route::resource('notes', NoteController::class);
});

        Language:php
        
    
<?php

namespace App\Models;

use Carbon\Carbon;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Casts\Attribute;
use Illuminate\Database\Eloquent\Factories\HasFactory;

class Note extends Model
{
    use HasFactory;

    /**
     * The attributes that are mass assignable.
     *
     * @var array<int, string>
     */
    protected $fillable = [
        'title',
        'slug',
        'note_details',
        'color_class',
    ];

    /**
     * This is a const background color arrays
     *
     * @var array<string>
     */
    public const BG_COLORS = [
        'bg-red-200',
        'bg-pink-200',
        'bg-yellow-200',
        'bg-purple-200',
        'bg-gray-200',
        'bg-cyan-200',
        'bg-orange-200',
        'bg-sky-200',
        'bg-blue-200',
    ];

    /**
     * Date formate d/m/y when get the data
     *
     * @param  string  $value
     * @return \Illuminate\Database\Eloquent\Casts\Attribute
     */
    protected function createdAt(): Attribute
    {
        return new Attribute(
            get: fn ($value) =>  Carbon::parse($value)->format('d/m/Y'),
        );
    }
}

        Language:php
        
    
<?php

namespace App\Http\Controllers;

use App\Models\Note;
use Illuminate\Support\Str;
use App\Http\Requests\NoteRequest;
use Illuminate\Support\Facades\Session;

class NoteController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index()
    {
        $notes = Note::get(['id', 'title', 'note_details', 'color_class', 'created_at']);
        return view('dashboard.notes.index', compact('notes'));
    }

    /**
     * Show the form for creating a new resource.
     */
    public function create()
    {
        return view('dashboard.notes.create');
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(NoteRequest $request)
    {
        $validated = $request->validated();
        $validated['slug'] = Str::slug($validated['title']);
        $validated['color_class'] = Note::BG_COLORS[array_rand(Note::BG_COLORS)];
        $note = Note::create($validated);

        if ($note) {
            Session::flash('success', 'Note Created Successfully.');
            return redirect()->route('dashboard.notes.index');
        } else {
            Session::flash('error', 'Note Create Failed!');
            return back();
        }
    }

    /**
     * Show the form for editing the specified resource.
     */
    public function edit(Note $note)
    {
        return view('dashboard.notes.edit', compact('note'));
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(NoteRequest $request, Note $note)
    {
        $validated = $request->validated();
        $validated['slug'] = Str::slug($validated['title']);
        $note->update($validated);

        if ($note) {
            Session::flash('success', 'Note Updated Successfully.');
            return redirect()->route('dashboard.notes.index');
        } else {
            Session::flash('error', 'Note Update Failed!');
            return back();
        }
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(Note $note)
    {
        $del = $note->delete();

        if ($del) {
            Session::flash('success', 'Note Deleted Successfully.');
            return redirect()->route('dashboard.notes.index');
        } else {
            Session::flash('error', 'Note Delete Failed!');
            return back();
        }
    }
}

        Language:php
        
    
<?php

namespace App\Http\Requests;

use Illuminate\Validation\Rule;
use Illuminate\Foundation\Http\FormRequest;

class NoteRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     */
    public function authorize(): bool
    {
        return true;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
     */
    public function rules(): array
    {
        $rules = [
            'title'        => ['required', 'string', 'max:255', Rule::unique('notes')->ignore($this->note)],
            'note_details' => ['required', 'string'],
            'color_class'  => ['nullable'],
        ];

        return $rules;
    }
}


        Language:php
        
    
<x-layout>
<div class="w-full mt-3">
    <div class="flex items-center justify-between">
        <h2 class="text-lg font-semibold text-gray-700">All Notes</h2>
        <a href="{{ route('dashboard.notes.create') }}">
            <i class="ri-add-circle-line ri-2x"></i>
        </a>
    </div>
</div>

<div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-5 my-5">
    @foreach ($notes as $note)
    <!-- Single Note item -->
    <div class="p-4 rounded-lg min-h-[280px] flex flex-col justify-between {{ $note->color_class }}">
        <!-- Note header -->
        <div>
            <div class="flex items-start justify-between mb-2 gap-x-3">
                <h3 class="text-xl font-bold">{{ $note->title }}</h3>
                <div class="flex gap-x-1">
                    <a href="{{ route('dashboard.notes.edit', $note->id) }}">
                        <i class="ri-edit-box-line ri-lg"></i>
                    </a>
                    <form action="{{ route('dashboard.notes.destroy', $note->id) }}" method="POST">
                        @csrf
                        @method('DELETE')

                        <button type="submit">
                            <i class="ri-delete-bin-line ri-lg"></i>
                        </button>
                    </form>
                </div>
            </div>

            <!-- Notes content  -->
            <p class="text-justify text-base font-normal">
                {{ $note->note_details }}
            </p>
        </div>
        <!-- Showing created at  -->
        <p class="text-md text-black mt-4">
            Created:
            <span class="font-semibold">{{ $note->created_at }}</span>
        </p>
    </div>
    @endforeach
</div> 
</x-layout>

        Language:blade
  • main.ts
  • App.vue
  • Home.vue
  • notes.ts
  • notesType.ts
import "./assets/main.css";
import "remixicon/fonts/remixicon.css";

import { createApp } from "vue";
import { createPinia } from "pinia";
import App from "./App.vue";
import router from "./router";

const app = createApp(App);

app.use(createPinia());
app.use(router);

app.mount("#app");

        Language:ts
        
    
<script setup lang="ts">
import { RouterView } from 'vue-router' 
import Navbar from "@/components/Navbar.vue";
import Footer from "@/components/Footer.vue";
</script>

<template> 
  <Navbar/>
  <main class="min-h-[85vh]">
    <div class="max-w-screen-xl flex flex-wrap items-center justify-between mx-auto p-4 mt-16"> 
      <RouterView />
    </div>
  </main>

  <Footer/>
</template>
        Language:js
        
    
<script setup lang="ts">
import { onMounted, ref } from "vue";
import { useModal } from "@/composables/useModal";
import Modal from "@/components/common/Modal.vue";
import { useNoteStore } from "@/stores/notes";
import { type NoteType } from "@/interfaces/notesType";
import moment from "moment";
import toast from "@/utils/Toaster";

const noteStore = useNoteStore();
const modal = useModal();
const updateModal = ref(false);
const noteModal = ref<NoteType>();
const { errorToast, successToast } = toast();

const openHandler = () => {
  updateModal.value = false;
  modal.showModal();
};

const editHandler = (note: NoteType) => {
  noteModal.value = note;
  updateModal.value = true;
  modal.showModal();
};

const deleteHandler = async (id: string) => {
  await noteStore.deleteNote(id);
  successToast("Delete note successfully.");
};

onMounted(() => {
  noteStore.getAllNotes();
});
</script>

<template>
  <div class="w-full mt-3">
    <div class="flex items-center justify-between">
      <h2 class="text-lg font-semibold text-gray-700">All Notes</h2>
      <button @click="openHandler">
        <i class="ri-add-circle-line ri-2x"></i>
      </button>
    </div>
  </div>

  <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-5 my-5">
    <!-- Single Note item -->
    <div
      v-for="(note, index) in noteStore?.allNotes"
      :key="index"
      class="p-4 rounded-lg min-h-[280px] flex flex-col justify-between"
      :class="note?.colorClass"
    >
      <!-- Note header -->
      <div>
        <div class="flex items-start justify-between mb-2 gap-x-3">
          <h3 class="text-xl font-bold">{{ note.title }}</h3>
          <div class="flex gap-x-1">
            <button @click="editHandler(note)">
              <i class="ri-edit-box-line ri-lg"></i>
            </button>
            <button @click="deleteHandler(note?._id)">
              <i class="ri-delete-bin-line ri-lg"></i>
            </button>
          </div>
        </div>

        <!-- Notes content  -->
        <p class="text-justify text-base font-normal">
          {{ note.note }}
        </p>
      </div>
      <!-- Showing created at  -->
      <p class="text-md text-black mt-4">
        Created:
        <span class="font-semibold">{{
          moment(note.createdAt).format("l")
        }}</span>
      </p>
    </div>
  </div>

  <Modal v-if="modal.isOpen.value" :update="updateModal" :note="noteModal" />
</template>

        Language:js
        
    
import { ref, computed } from "vue";
import { defineStore } from "pinia";
import { type NoteType } from "@/interfaces/notesType";
import axios from "axios";

const apiUrl = '({}).VITE_API_ENDPOINT';

export const useNoteStore = defineStore("notes", () => {
  const notes = ref<NoteType[]>([]);
  const allNotes = computed(() => notes.value);

  async function getAllNotes() {
    await axios
      .get('$ {apiUrl}/notes')
      .then((res) => {
        notes.value = res?.data;
      })
      .catch((err) => {
        console.log(err);
      });
  }

  async function addNote(note: NoteType) {
    await axios
      .post('$ {apiUrl}/notes', note)
      .then((res) => {
        getAllNotes();
        console.log(res);
      })
      .catch((err) => {
        console.log(err);
      });
  }

  async function updateNote(noteId: string, note: NoteType) {
    await axios
      .patch('$ {apiUrl}/notes/{noteId}', note)
      .then((res) => {
        getAllNotes();
      })
      .catch((err) => {
        console.log(err);
      });
  }

  async function deleteNote(noteId: string) {
    await axios
      .delete('$ {apiUrl}/notes/{noteId}')
      .then((res) => {
        getAllNotes();
      })
      .catch((err) => {
        console.log(err);
      });
  }

  return { notes, allNotes, addNote, getAllNotes, deleteNote, updateNote };
});

        Language:ts
        
    
export interface NoteType {
  title: string;
  note: string;
  colorClass: string;
  createdAt?: string;
}






        Language:ts
  • index.jsx
  • App.jsx
  • Note.jsx
  • Dashboard.jsx
  • Modal.jsx
import React from "react";
import ReactDOM from "react-dom/client";
import { RouterProvider } from "react-router-dom";
import router from "./router/router";
import "./index.css";
import "remixicon/fonts/remixicon.css";

ReactDOM.createRoot(document.getElementById("root")).render(
  <React.StrictMode>
    <RouterProvider router={router} />
  </React.StrictMode>
);

        Language:js
        
    
import Navbar from "./components/Navbar";
import Footer from "./components/Footer";
import { Outlet } from "react-router-dom";
import { ToastContainer } from "react-toastify";

function App() {
  return (
    <>
      <ToastContainer />
      {/* Navbar  */}
      <Navbar />

      {/* Main content start */}
      <main className="min-h-[85vh]">
        <div className="max-w-screen-xl flex flex-wrap items-center justify-between mx-auto p-4 mt-8">
          <Outlet />
        </div>
      </main>
      {/* Main content ends */}

      {/* Footer */}
      <Footer />
    </>
  );
}

export default App;


        Language:js
        
    
import React, { useRef } from "react";
import Modal from "./Modal";
import moment from "moment";

const Note = ({ note, deleteNote, getAllNotes }) => {
  const ChildRef = useRef();

  return (
    <>
      <div
        className={'p-4 rounded-lg min-h-[280px] flex flex-col justify-between bg-green-200 $ {note.colorClass}'}
      >
        <div>
          <div className="flex items-start justify-between mb-2 gap-x-3">
            <h3 className="text-xl font-bold">{note.title}</h3>
            <div className="flex gap-x-1">
              <button onClick={() => ChildRef.current.openModal()}>
                <i className="ri-edit-box-line ri-lg"></i>
              </button>
              <button onClick={() => deleteNote(note._id)}>
                <i className="ri-delete-bin-line ri-lg"></i>
              </button>
            </div>
          </div>

          <p className="text-justify text-base font-normal">{note.note}</p>
        </div>

        <p className="text-md text-black mt-4">
          Created:
          <span className="font-semibold ml-1">
            {moment(note.createdAt).format("l")}
          </span>
        </p>
      </div>

      <Modal ref={ChildRef} note={note} getAllNotes={getAllNotes} />
    </>
  );
};

export default Note;


        Language:js
        
    
import React, { useEffect, useRef, useState } from "react";
import axios from "axios";
import Note from "../../components/common/Note";
import Modal from "../../components/common/Modal";
import toaster from "../../utils/Toaster.js";

const DashboardPage = () => {
  const { errorToast, successToast } = toaster();
  const [notes, setNotes] = useState([]);

  const ChildRef = useRef();

  async function getAllNotes() {
    try {
      await axios
        .get('http://localhost:3010/api/v1/notes')
        .then((res) => {
          setNotes(res.data);
        })
        .catch((err) => {
          errorToast(err);
          console.log(err);
        });
    } catch (error) {
      console.log(error);
    }
  }

  // Calling the API
  useEffect(() => {
    getAllNotes();
  }, []);

  async function deleteNote(noteId) {
    try {
      await axios
        .delete('http://localhost:3010/api/v1/notes/$ {noteId}')
        .then(() => {
          successToast("Note Deleted Successfully");
          getAllNotes();
        })
        .catch((err) => {
          errorToast(err);
          console.log(err);
        });
    } catch (error) {
      console.log(error);
    }
  }

  return (
    <>
      <div className="w-full mt-8">
        <div className="flex items-center justify-between">
          <h2 className="text-lg font-semibold text-gray-700">All Notes</h2>
          <button onClick={() => ChildRef.current.openModal()}>
            <i className="ri-add-circle-line ri-2x"></i>
          </button>
        </div>
      </div>

      <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-5 my-5">
        {notes &&
          notes.map((note) => {
            return (
              <Note
                key={note._id}
                note={note}
                deleteNote={deleteNote}
                getAllNotes={getAllNotes}
              />
            );
          })}
      </div>

      <Modal ref={ChildRef} getAllNotes={getAllNotes} />
    </>
  );
};

export default DashboardPage;

        Language:js
        
    
import React, {
  forwardRef,
  useEffect,
  useImperativeHandle,
  useState,
} from "react";
import { bgColorArray } from "../../data/bgColor";
import axios from "axios";
import toaster from "../../utils/Toaster.js";

const { errorToast, successToast } = toaster();
const Modal = (props, ref) => {
  const [isOpen, setIsOpen] = useState(false);
  const [noteParams, setNoteParams] = useState({
    id: "",
    title: "",
    note: "",
    colorClass: "",
  });

  useImperativeHandle(ref, () => ({
    openModal,
  }));

  function closeModal() {
    setIsOpen(false);
  }

  function openModal() {
    setIsOpen(true);
  }

  // two way data binding
  const inputHandler = (e) => {
    e.persist();
    setNoteParams({ ...noteParams, [e.target.name]: e.target.value });
  };

  // Create a new note
  const createNoteHandler = async () => {
    const storeData = {
      title: noteParams.title,
      note: noteParams.note,
      colorClass: bgColorArray[Math.floor(Math.random() * bgColorArray.length)],
    };
    try {
      await axios
        .post('http://localhost:3010/api/v1/notes', storeData)
        .then((res) => {
          props.getAllNotes();
          setNoteParams({ title: "", note: "" });
          closeModal();
          successToast("Note Created Successfully");
        })
        .catch((err) => {
          errorToast(err);
          console.log(err);
        });
    } catch (error) {
      console.log(error);
    }
  };

  // Updated note
  const updateNoteHandler = async (noteId) => {
    const { id, ...newParams } = noteParams;
    try {
      await axios
        .patch('http://localhost:3010/api/v1/notes/$ {noteId}', newParams)
        .then((res) => {
          props.getAllNotes();
          closeModal();
          successToast("Note Updated Successfully");
        })
        .catch((err) => {
          errorToast(err);
          console.log(err);
        });
    } catch (error) {
      console.log(error);
    }
  };

  // Mounted the notes value
  useEffect(() => {
    if (props?.note) {
      setNoteParams({
        id: props?.note?._id,
        title: props?.note?.title,
        note: props?.note?.note,
        colorClass: props?.note?.colorClass,
      });
    }
  }, []);

  if (!isOpen) return null;

  return (
    <div>
      <div className="bg-black opacity-80 fixed inset-0 z-[100]"></div>
      <div className="overflow-y-auto overflow-x-hidden fixed top-0 right-0 left-0 w-full md:inset-0 h-[calc(100%-1rem)] max-h-full justify-center items-center flex !z-[101] backdrop-blur-sm">
        <div className="relative p-4 max-w-2xl max-h-full md:h-auto">
          <div className="relative bg-white rounded-lg shadow overflow-hidden mb-5 w-[300px] md:w-[600px]">
            {/* Modal header */}
            <div className="modal-header flex items-center justify-between p-4">
              <h4 className="text-lg font-semibold text-black">
                {props?.note ? "Update" : "Create a"} Note
              </h4>

              <span
                onClick={() => closeModal()}
                className="text-black cursor-pointer hover:bg-gray-400 hover:text-white rounded-full p-1"
              >
                <i className="ri-close-line ri-xl"></i>
              </span>
            </div>
            <hr />

            {/* Modal body */}
            <div className="modal-body p-4 text-black">
              <div>
                <label htmlFor="title">Note title</label>
                <input
                  onChange={inputHandler}
                  v-model="noteParams.title"
                  type="text"
                  name="title"
                  id="title"
                  value={noteParams.title}
                  className="w-full border border-gray-200 mt-1 py-1 px-2"
                />
              </div>

              <div className="mt-2">
                <label htmlFor="note">Write your note</label>
                <textarea
                  onChange={inputHandler}
                  v-model="noteParams.note"
                  name="note"
                  id="note"
                  rows="6"
                  value={noteParams.note}
                  className="w-full border border-gray-200 mt-1 py-1 px-2"
                ></textarea>
              </div>
            </div>

            {/* Modal footer */}
            <div className="flex flex-col p-4 gap-y-3">
              {props?.note ? (
                <button
                  onClick={() => updateNoteHandler(noteParams.id)}
                  className="bg-cyan-400 px-4 py-2 block w-full text-white font-semibold"
                >
                  Update
                </button>
              ) : (
                <button
                  onClick={() => createNoteHandler()}
                  className="bg-blue-400 px-4 py-2 block w-full text-white font-semibold"
                >
                  Create
                </button>
              )}

              <button
                onClick={() => closeModal()}
                className="bg-red-400 px-4 py-2 block w-full text-white font-semibold"
              >
                Cancel
              </button>
            </div>
          </div>
        </div>
      </div>
    </div>
  );
};

export default forwardRef(Modal);

        Language:js
  • main.ts
  • create-note.dto.ts
  • note.controller.ts
  • note.module.ts
  • note.service.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ValidationPipe, VersioningType } from '@nestjs/common';

async function bootstrap() {
  const app = await NestFactory.create(AppModule, { cors: true });
  app.useGlobalPipes(
    new ValidationPipe({
      whitelist: true,
      forbidNonWhitelisted: true,
    }),
  );
  app.enableVersioning({
    type: VersioningType.URI,
    defaultVersion: '1',
    prefix: 'api/v',
  });
  await app.listen(parseInt(process.env.APP_PORT));
}
bootstrap();

        Language:ts
        
    
import { IsString, IsNotEmpty, IsOptional } from 'class-validator';
import { NoteEntity } from '../entities/note.entity';

export class CreateNoteDto extends NoteEntity {
  @IsString()
  @IsNotEmpty({ message: 'Title should not be empty' })
  readonly title: string;

  @IsString()
  @IsNotEmpty({ message: 'Note should not be empty' })
  readonly note: string;

  @IsString()
  @IsNotEmpty({ message: 'Color class should not be empty' })
  readonly colorClass: string;
}

        Language:ts
        
    
import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
  ValidationPipe,
  UsePipes,
} from '@nestjs/common';
import { NotesService } from './notes.service';
import { CreateNoteDto } from './dto/create-note.dto';
import { UpdateNoteDto } from './dto/update-note.dto';
import { iNote } from './interfaces/note.interface';

@Controller('notes')
export class NotesController {
  constructor(private readonly notesService: NotesService) {}

  @Post()
  @UsePipes(new ValidationPipe())
  create(@Body() createNoteDto: CreateNoteDto): Promise<iNote> {
    return this.notesService.create(createNoteDto);
  }

  @Get()
  findAll(): Promise<iNote[]> {
    return this.notesService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string): Promise<iNote> {
    return this.notesService.findOne(id);
  }

  @Patch(':id')
  @UsePipes(new ValidationPipe())
  update(
    @Param('id') id: string,
    @Body() updateNoteDto: UpdateNoteDto,
  ): Promise<iNote> {
    return this.notesService.update(id, updateNoteDto);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.notesService.remove(id);
  }
}

        Language:ts
        
    
import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { NotesService } from './notes.service';
import { NotesController } from './notes.controller';
import { NoteSchema } from './schema/note.schema';

@Module({
  imports: [MongooseModule.forFeature([{ name: 'note', schema: NoteSchema }])],
  controllers: [NotesController],
  providers: [NotesService],
  exports: [NotesService],
})
export class NotesModule {}

        Language:ts
        
    
import { Injectable, NotFoundException } from '@nestjs/common';
import { CreateNoteDto } from './dto/create-note.dto';
import { UpdateNoteDto } from './dto/update-note.dto';
import { Model } from 'mongoose';
import { InjectModel } from '@nestjs/mongoose';
import { iNote } from './interfaces/note.interface';

@Injectable()
export class NotesService {
  constructor(@InjectModel('note') private readonly noteModel: Model<iNote>) {}

  async create(createNoteDto: CreateNoteDto): Promise<iNote> {
    return await new this.noteModel(createNoteDto).save();
  }

  async findAll(): Promise<iNote[]> {
    const noteData = await this.noteModel.find(
      {}
    );
    if (!noteData || noteData.length == 0) {
      throw new NotFoundException('Notes data not found!');
    }
    return noteData;
  }

  async findOne(id: string): Promise<iNote> {
    const existingNote = await this.noteModel
      .findById(id)
      .exec();
    if (!existingNote) {
      throw new NotFoundException('Note #$ {id} not found');
    }
    return existingNote;
  }

  async update(id: string, updateNoteDto: UpdateNoteDto): Promise<iNote> {
    const existingNote = await this.noteModel.findByIdAndUpdate(
      id,
      updateNoteDto,
    );
    if (!existingNote) {
      throw new NotFoundException('Note #$ {id} not found');
    }
    return existingNote;
  }

  async remove(id: string) {
    const deletedNote = await this.noteModel.findByIdAndDelete(id);
    if (!deletedNote) {
      throw new NotFoundException('Note #$ {id} not found');
    }
    return deletedNote;
  }
}

        Language:ts

About Me

< Who am I ? />

A story of hard work and perseverance

I currently work as a Software Engineer - II at Jatri. My experience as a software engineer has been active, varied, and has encompassed a variety of technologies over the course of 4+ years. For creating reliable backend systems, PHP and Laravel are my primary areas of competence. Concurrently, I have refined my abilities in TypeScript and JavaScript, building dynamic and adaptable user interfaces with the help of the Vue.js and Nuxt.js frameworks. I have experience using Vuex and Pinia for state management, both of which have helped me improve productivity and simplify the development of complex Vue apps. Additionally, I have integrated REST APIs and GraphQL for efficient data retrieval, ensuring smooth communication between various software components.

My technical versatility has grown due to my core knowledge of React and React Router, as well as my expertise with Nest.js, MongoDB, and Docker. This has helped me to adapt to a variety of tech stacks and project requirements. I prioritize performance optimization, applying techniques such as database indexing, eager loading, and query optimization to ensure efficient data access and minimize bottlenecks.

I also emphasize the importance of following design patterns and principles to write clean, maintainable, and scalable code. I know how to effectively use search engines like Google and ChatGPT to solve problems, stay updated on best practices, and boost productivity.

My 4+ years as a Software Engineer have given me a well-rounded skill set that includes backend development, frontend technologies, database management, system architecture, and more. This has allowed me to contribute successfully to comprehensive and high-quality software solutions in a variety of environments.

hasibul hasan shanto

Experience & Education

< Where have I worked and studied ? />

  • Experience
  • Education
  • Activities

Rubaiyat Tower, Level-3, Gulshan-2, Dhaka

Software Engineer - II

November 2022 - Present

Jatri is a public transport journey planner, digital ticketing and mobility marketplace, driving productivity by helping drivers to offer reliable transport to the commuters through our state-of-the-art technology.

274, Shah Kabir Mazar Rd, Dakshin Khan, Dhaka 1230

Laravel Web Apps Developer

March 2021 - October 2022

ITclan BD offers quality web services from Website Design to Software Development, E-Commerce Services, Mobile app development, Search Engine Optimization (SEO), Digital Marketing and Creatives with 3D Animation. ITclan BD aims to ensure its customers have a win-win situation and the projects deliver a solid ROI with timely delivery of the services.

Sector 3, Uttara, Dhaka 1230

Jr. Full-Stack Web Developer

September 2020 - February 2021

We deliver world-class WordPress development solutions to our WooCommerce clients and maintain 100% quality assurance. So, our clients get the best WooCommerce service from WooXperto LLC Team.

Dhanmondi, Dhaka-1209

Web Application Developer (Intern)

March 2019 - May 2019

Preneur Lab is a social good company focusing on solving problems related to youth, women, and entrepreneurs. It started as an innovation lab to empower young people to build digital solutions to solve social problems in 2013 but later changed the model to build solutions and services at it’s own. Community engagement, innovative ideas, and young team are our major strengths.

gono bishwabidwalay logo

Gono Bishwabidyalay

Computer Science and Engineering (CSE)

Nolam, Savar, Dhaka 1344

September 2014 - April 2019
dhaka college logo

Dhaka College

Political Science (Honors 1st year)

New Market, Dhaka 1205

September 2012 - August 2014
gopalpur college logo

Gopalpur Govt. College

Science Department (2nd Year)

Gopalpur, Tangail

July 2011 - April 2012
bsmarpc logo

Birshreshtha Munshi Abdur Rouf Public College

Science Department (1st Year)

Peelkhana, BGB Head Quarters, Dhaka 1205

July 2010 - June 2011
suti-vm logo

Suti V.M. Pilot Model Govt. High School

Class 6 to 10

Gopalpur, Tangail

January 2005 - March 2010

Google Developers Group - GDG Bangla

Campus Ambassador

February 2016 - February 2019

I participated in “Banglar Jonno 4 Lakh” Campaign in my campus as an organizer representing my club. I worked as a volunteer Google IO extended ’17 where 2000 IT enthusiasts participated.

Mozilla Campus Club Gono Bishwabidyalay

Founder and Club Lead

January 2015 - February 2019

Four programs have been organized by me in my university campus under the custody of Mozilla Q.A Bangladesh. Besides, I have participated about 40+ online and offline Q.A test day of Mozilla Firefox.

Winner of Hour of code

Organized by CodersTrust and Code.org

December 2015

Winner of “Hour of code” at “Northern University of Bangladesh” Organized by CodersTrust and Code.org in 2015.

My Services

< What I do ? />

Full-stack

Full-Stack Development

  • Robust backend with Interactive frontend

  • Modern backend with Laravel or Nest JS

  • Modern frontend with Vue, Nuxt or React JS

  • Industry level best architecture

  • Database design and optimizations

Backend

Backend Development

  • Modern backend with Laravel or Nest JS

  • MySql or MongoDB Database

  • JWT, Sanctum or Breeze Authentication

  • Database indexing and optimizations

  • Caching data using Redis

Frontend

Frontend Development

  • Interactive frontend with Vue or React JS

  • Server side SEO friendly with Nuxt JS

  • UI design with Tailwind CSS or Bootstrap

  • Optimization for faster loading

  • Custom CSS using SCSS

Clients Testimonials

< What clients say />

What My CustomersAre Saying!

Leverage agile frameworks to provide a robust synopsis for high level overviews. Iterative approaches to corporate strategy foster collaborative thinking to further the overall value proposition. Organically grow the holistic world view of disruptive innovation via workplace diversity and empowerment.

Bring to the table win-win survival strategies to ensure proactive domination. At the end of the day, going forward, a new normal that has evolved from generation X is on the runway heading towards a streamlined cloud solution. User generated content in real-time will have multiple touchpoints for offshoring.

Capitalize on low hanging fruit to identify a ballpark value added activity to beta test. Override the digital divide with additional click throughs from DevOps. Nanotechnology immersion along the information highway will close the loop on focusing solely on the bottom line.

Winter Doe

CTO, XYZ Corp.

Love to do

< What I'm doing in my free time />

    Playing Chess

    Reading

    Traveling

    Mountain Hiking