Available for opportunities
Nguyen Minh Toan

Nguyen Minh Toan

Building high-performance, secure, and scalable web applications with precision-engineered architecture.

developer.profile.ts
const developer = {
  focus: "Performance & Scale",
  latency: <50ms,
  uptime: 99.9%
};
View Projects
Open Terminal
1
Years
5
Projects
99
% Uptime
Scroll
Core Expertise

Engineering Excellence

Fullstack expertise từ database đến pixel-perfect interface — được xây dựng qua từng dự án thực tế.

Backend

System Architecture

Thiết kế backend mạnh mẽ với Laravel & NestJS, áp dụng Repository Pattern, SOLID principles và clean architecture.

// Repository Pattern
interface UserRepository {
  findById(id: string): Promise<User>;
}
200+
API Endpoints
<50ms
Response Time
Laravel
NestJS
REST API
Queue
Frontend

Modern UI & UX

Xây dựng giao diện React/Next.js hiện đại với TypeScript, responsive design và micro-interactions đẹp mắt.

const App = () => (
  <Layout responsive>
    <UI animated />
  </Layout>
);
100+
Components
95+
Lighthouse
React
Next.js
TypeScript
Tailwind
Database

Performance & Optimization

Tối ưu hóa N+1 queries, triển khai Redis caching, thiết kế schema MySQL chuẩn ACID với sub-50ms response.

// Redis caching
await redis.setex(
  'users:all', 300,
  data
)
98%
Cache Hit Rate
23ms
Avg Response
MySQL
Redis
N+1 Fix
MongoDB
DevOps

Infrastructure & Deploy

Containerization với Docker, deploy lên AWS, cấu hình Nginx reverse proxy và CI/CD pipeline hiệu quả.

# docker-compose
services:
  app:
    image: laravel:prod
    restart: always
99.9%
Uptime
<5min
Deploy Time
Docker
AWS S3
Nginx
Git
Tech Stack

Tools of the Trade

Công nghệ tôi sử dụng hàng ngày để xây dựng sản phẩm chất lượng cao.

Backend

Laravel
PHP
NestJS
Node.js
REST API

Frontend

React
Next.js
TypeScript
Tailwind
TanStack

Database

MySQL
Redis
MongoDB
Prisma
Query Opt

DevOps

Docker
AWS S3
Nginx
Git
Linux
Experience

The Journey

From first line of code to architecting scalable systems.

2024 — PresentCurrent

Full-Stack Web Developer

INFINILAB — Cầu Giấy, Hà Nội

Owned feature development end-to-end across backend and frontend for enterprise CRM and B2B platforms—from database design and API implementation to React UI integration—delivering production-ready features independently.

Optimized backend performance and query execution; eliminated N+1 query bottlenecks using Eloquent Eager Loading and applied Composite Indexes, reducing API response times by 40% in production.

Enhanced application security; configured strict Content-Security-Policy (CSP) and X-Frame-Options on Nginx to mitigate Clickjacking, and neutralized SQLi/XSS risks globally via ORM prepared statements and strict server-side validation.

Implemented secure stateless API authentication using JWT with instant session revocation via a Redis-backed token blacklist; applied Redis-based Rate Limiting to protect public endpoints against scraping and brute-force traffic.

Improved client-side data reliability by implementing TanStack Query (caching, background refetching, optimistic updates), reducing redundant API calls and keeping UI state consistent.

Delivered complex multi-step form workflows and conditional validation using React Hook Form & Zod, improving data integrity and system stability.

Implemented async task processing using Laravel Horizon and Redis queues for background operations (email notifications, report generation, image processing), reducing request-response cycle time by ~45%.

LaravelReactNext.jsMySQLRedisTanStack QueryReact Hook FormZodNginxDockerLaravel Horizon
09/2024 — 12/2024

Intern .NET Web Developer

DEHA VietNam

Built a full-featured movie ticket booking and streaming platform from the ground up using ASP.NET Core, Entity Framework Core, MySQL, and Docker containerization.

Implemented real-time seat selection leveraging SignalR WebSocket connections, allowing multiple users to see seat availability updates instantly without page refresh.

Integrated a secure end-to-end booking flow with ZaloPay QR Code payment gateway, handling callback verification, transaction idempotency, and order state management.

Designed normalized database schema for movies, showtimes, seats, bookings, and payments with proper indexing strategies for read-heavy queries.

Developed admin dashboard for theater staff to manage movie schedules, pricing tiers, and view real-time booking analytics.

ASP.NET CoreEntity Framework CoreMySQLDockerSignalRZaloPay
Code Showcase

Real Code, Real Impact

Snippets that demonstrate my approach to solving real engineering problems.

InvoiceService.php
readonlyACID
<?php
declare(strict_types=1);
namespace App\Services;
use App\Enums\InvoiceStatus;
use Illuminate\Support\Facades\DB;
final readonly class InvoiceService
implements InvoiceServiceInterface
{
  public function __construct(
    private InvoiceRepositoryInterface $repository,
  ) {}
  public function create(
    array $payload,
    User $actor
  ): Invoice
  {
    DB::beginTransaction();
    try {
      $payload['issued_by'] = $actor->id;
      $payload['status'] = InvoiceStatus::UNPAID->value;
      if (!empty($payload['fee_types'])) {
        $payload['total_amount'] = array_sum(
          array_column($payload['fee_types'], 'amount')
        );
      }
      $invoice = $this->repository->create($payload);
      $this->repository->syncFeeTypes($invoice, $payload['fee_types']);
      DB::commit();
      return $invoice->load(['student.profile', 'feeTypes']);
    } catch (\Throwable $e) {
      DB::rollBack();
      throw $e;
    }
  }
}
RateLimitService.php
Lua0 race
final class RateLimitService
{
  private const string PREFIX = 'ratelimit';
  private const int MAX = 10;
  public function check(string $id): array
  {
    $key = "ratelimit:" . md5($id);
    $lua = """
      local k = KEYS[1]
      local now = tonumber(ARGV[1])
      redis.call('ZREMRANGEBYSCORE', k, '-inf', now - 60)
      local c = redis.call('ZCARD', k)
      if c >= 10 then
        return {0, c, retry}
      end
      redis.call('ZADD', k, now, ARGV[4])
      redis.call('EXPIRE', k, 60)
      return {1, c+1, 0}
    """;
    $result = Redis::eval(
      $lua, 1, $key,
      microtime(true), 60, self::MAX,
      uniqid()
    );
    return [
      'allowed' => (bool) $result[0],
      'remaining' => self::MAX - $result[1],
    ];
  }
}
AuthService.php
JWTanti-theft
final class AuthService
{
  public function rotate(string $rawToken): array
  {
    $hash = hash('sha256', $rawToken);
    $record = RefreshToken::where('token_hash', $hash)->first();
    // 🚨 Theft Detection: revoked token reused
    if ($record && $record->revoked_at !== null) {
      RefreshToken::where('user_id', $record->user_id)
        ->whereNull('revoked_at')
        ->update(['revoked_at' => now()]);
      throw new SecurityException('Token reuse detected.');
    }
    if (!$record || $record->expires_at->isPast()) {
      throw new AuthenticationException();
    }
    $record->update(['revoked_at' => now()]);
    return $this->issuePair($record->user);
  }
  private function issuePair(User $user): array
  {
    $access = auth('api')->login($user);
    $refresh = Str::random(64);
    RefreshToken::create([
      'user_id' => $user->id,
      'token_hash' => hash('sha256', $refresh),
      'expires_at' => now()->addDays(7),
    ]);
    return ['access_token' => $access,
      'refresh_token' => $refresh,
      'token_type' => 'Bearer',
    ];
  }
}
AccessPolicy.php
enummatch
enum InvoiceStatus: string
{
  case UNPAID = 'unpaid';
  case PAID = 'paid';
  case OVERDUE = 'overdue';
}
private function canView(
  Invoice $invoice,
  User $user
): bool
{
  return match (true) {
    $user->hasRole(['admin', 'principal']) => true,
    $user->hasRole('student')
      && $user->student?->id === $invoice->student_id
      => true,
    $user->hasRole('parent')
      && $user->guardianStudents()
        ->where('students.id', $invoice->student_id)
        ->exists()
      => true,
    default => false,
  };
}
By The Numbers

Impact Dashboard

0+
Projects Delivered
0ms
Avg Response Time
0.0%
Uptime Guarantee
0K+
Lines of Code
Architecture

How I Build

ClientNext.js / React
API GatewayNestJS / Laravel
Data LayerMySQL + Redis
SOLID
Clean Architecture
DRY
Zero Duplication
O(1)
Constant Lookups
99.9%
Reliability