Redesign in progress :]

Mohamed Nafih K T
Software Developer

Been building with Java. Comfortable across the stack.

Illustrated portrait of Mohamed Nafih K T

About

From Electrical to Computers.

I am a Software Developer with B.Tech in Electrical and Electronics Engineering. During college, my interest gradually shifted from hardware to the software running behind the systems I was studying, which led me to start building applications on my own.

Most of what I learned came from building projects rather than following tutorials. Over time, that grew into working with Java, Spring Boot, React, databases, Android development, and a few systems-focused projects that eventually turned me into someone who loves designing the systems.

I'm not claiming to be the most brilliant engineer in the room, since there's always another level to reach, and I intend to keep learning, improving, and striving toward it throughout my life. I want the things I build to be accessible, reliable, and respectful of the people using them, with privacy and security treated as part of the design, not an afterthought.

B.Tech, Electrical & Electronics Engineering

Built my foundation in digital electronics, microprocessors, embedded systems, and problem solving.

Started building software independently

Began learning Java and web development through self-driven projects alongside college.

Java Full Stack Development Trainee

Trained in Java, Spring Boot, React, PostgreSQL, and built CarCentral as a full-stack capstone project.

Software Developer

Continuing to build projects while looking for opportunities to contribute as a backend or full-stack engineer.

work

Projects I've worked on.

These projects are where most of my learning happened. Some began out of curiosity, some because I needed them, and some simply grew much bigger than I expected.

PacketScope started as a mini project while learning java. Around the same time, I was learning how network packets worked and had just started using Postman to test APIs and mock HTTP requests.

What began as a small Java exercise gradually grew into something completely different. The more I learned about networking, the more the project shifted away from being a course assignment and became a way for me to explore, inspect, and understand how network traffic actually behaves.

It eventually evolved into a packet analysis platform with traffic capture, inspection, replay, and analytics features.

Implementation highlights

Live packet capture engine

Captures IPv4 and IPv6 TCP/UDP packets in real time using Pcap4J and extracts protocol metadata for analysis.

Asynchronous processing pipeline

Built a producer–consumer queue so packet capture, processing, and database writes happen independently without blocking incoming traffic.

Batch persistence layer

Stores captured packets in transactional batches through JDBC, reducing database overhead during heavy traffic.

Traffic analytics dashboard

Exposes captured traffic through a lightweight REST API and visualizes protocol distribution and network activity using Chart.js.

HTTP replay & inspection

Reconstructs captured HTTP requests so they can be inspected and replayed directly from the dashboard for debugging and learning.

CarCentral began as the final project for my Java Full Stack course, but I didn't want it to be another e-commerce or CRUD application.

I had always liked how OLX made buying and selling used things simple, but buying a second-hand car still felt incomplete. Buyers had to figure out the vehicle's condition, find a mechanic, search for spare parts, and manage everything across different platforms.

So I imagined a single place built specifically for car owners — a platform where you could discover second-hand cars from dealerships, book servicing, buy parts, and manage the entire ownership journey in one application.

Implementation highlights

JWT authentication & authorization

Implemented secure login with Spring Security using JWT tokens, with separate customer and administrator roles protected by role-based access control.

Booking lifecycle workflow

Designed a state-driven booking flow where service requests move through Pending → Approved → Paid → Completed, ensuring every action follows a valid transition.

Stripe payment integration

Integrated Stripe PaymentIntent APIs with webhook verification so bookings are marked as paid only after successful payment confirmation from Stripe.

REST API backend

Built RESTful APIs for authentication, vehicles, services, bookings, parts, orders, and user management using Spring Boot and PostgreSQL.

Relational data model

Designed normalized PostgreSQL schemas connecting users, dealerships, vehicles, services, parts, bookings, payments, and order history through JPA entity relationships.

Responsive customer & admin interface

Developed separate React interfaces for customers and administrators, connected through authenticated APIs for inventory, bookings, and order management.

Equibo started because I wanted to automate my own trading instead of placing every trade manually.

Most FOSS trading bots I came across were either tightly coupled to a single broker, difficult to customize, or fragile enough that changing one part often broke another.

So I built my own trading engine around a different idea: every piece should be modular and replaceable. Strategies, indicators, risk management, broker integration, and backtesting all live as independent components that can evolve without rewriting the rest of the system.

Implementation highlights

Modular trading engine

Built the engine as independent modules for market scanning, strategy execution, risk management, broker integration, and notifications, so each component can be replaced without affecting the rest of the system.

Shared strategy engine

Designed a single strategy pipeline that runs against both historical market data for backtesting and live market feeds for execution, keeping trading logic consistent across both modes.

Risk management layer

Every trade passes through a dedicated risk engine that validates position sizing, capital allocation, stop-loss, and trade limits before an order can be executed.

Market data processing

Aggregates OHLCV candle data and computes technical indicators such as RSI, ATR, EMA, SMA, and TSI before passing signals to the strategy engine.

Broker adapter architecture

Separated broker-specific APIs behind an adapter layer, making it possible to support different brokers without changing the core trading engine.

Trade logging & notifications

Maintains structured trade logs and sends execution updates through Telegram, making strategy behaviour easier to monitor and debug.

Records began for a very simple reason: my phone ran stock Android and it didn't have a proper notes app that I actually liked using.

Google Keep was there, but it wasn't enough for me. It lacked proper note organization, didn't have a dedicated app lock, and every note was tied to my Google account.

I wanted something different. My idea was simple: what needs to stay on my phone should stay on my phone. That became the foundation of Records — an offline-first notes app built around privacy, encryption, and keeping user data under the user's control.

Implementation highlights

Privacy-first architecture

Designed the application so note content is encrypted before it is written to storage, keeping sensitive data unreadable without the user's password.

Offline-first storage

Built entirely around Room Database, allowing every feature to work locally without relying on cloud storage or an internet connection.

Encrypted local database

Implemented AES-256-GCM encryption for note content, with encryption keys derived from the user's password so plaintext is never stored on disk.

Search over encrypted notes

Used HMAC-SHA256 blind indexing to make encrypted notes searchable without exposing their original content.

Secure data lifecycle

Added encrypted backups, automatic locking after inactivity, and a recycle bin with timed deletion as part of the app's security model.

QkChat began while I was working at a textile shop in Kochi. A customer asked me to send photos of a dress that would arrive later, and I realized how often I had these short, one-time conversations with people.

Most of them didn't need to become permanent contacts, but sharing my phone number always felt unnecessary. I wanted a way to create a temporary conversation, share what was needed, and leave without exchanging identities or keeping chat history.

It later became useful in another situation I kept running into at school and on public computers. Whenever I needed to transfer a file, I often had to log into my personal email or WhatsApp on someone else's device because Bluetooth failed or the devices weren't compatible. QkChat became a simple alternative: open a room, share the file, close it, and walk away without leaving my account logged in on that device.

Implementation highlights

Client-side encryption

Messages are encrypted in the browser using the Web Crypto API before being sent, so the server never sees plaintext message content.

Password-derived room keys

Encryption keys are derived from a shared room password using PBKDF2, allowing participants to independently generate the same key without exchanging it through the server.

Ephemeral messaging architecture

Built the server as a Socket.IO relay with no database or persistent chat storage, so conversations disappear once participants leave the room.

Real-time communication pipeline

Implemented encrypted message delivery, room management, typing indicators, and connection lifecycle handling over WebSockets.

Cross-platform client

Built with React and Capacitor so the same application can run on the web and Android from a shared codebase.

skills

Technologies I have worked with.

The languages, frameworks, databases, networking libraries, and tools I've been using across the projects on this portfolio.

Languages

Java Java
Kotlin Kotlin
Python Python
JavaScript JavaScript

Frameworks

Spring Boot Spring Boot
Spring Security Spring Security
React React
Node.js Node.js
Express Express
Tailwind CSS Tailwind CSS
JavaFX JavaFX
Jetpack Compose Jetpack Compose

Databases

PostgreSQL PostgreSQL
MySQL MySQL
Hibernate Hibernate / JPA
Room Database Room

Networking & Security

REST APIs REST APIs
WebSockets WebSockets
JWT JWT
Stripe Stripe API
Pcap4J Pcap4J

Developer Tools

Git Git
GitHub GitHub
Docker Docker
Maven Maven
Postman Postman
IntelliJ IDEA IntelliJ IDEA
VS Code VS Code
Linux Linux

Contact

Hello!... Let's connect.

Questions, suggestions, feedback, collaboration, or no particular reason at all— feel free to reach out.