authentisign

• 

  Secure User Authentication — JWT-based login protects access to the verification system

• 

  Signature Verification Dashboard — Upload a reference signature and a test signature for AI analysis

• 

  Forgery Detection — AI identifies a mismatch and returns a FORGED verdict with confidence scoring

• 

  AI Analysis Result — Embedding distance and side-by-side comparison support the forgery decision

• 

  Genuine Signature Verification — Similar signatures are recognized as GENUINE by the Siamese model

• 

  Similarity Analysis — Low embedding distance indicates that the two signatures belong to the same writer

• 

  Verification History — Users can review previous genuine/forged results and their confidence scores

Inspiration

I built a project called AuthentiSign. The main goal of this project is to distinguish between genuine and forged signatures.

Let me tell you why I decided to build this project.

The idea came from a simple question:

Do identical twins have the same signature or handwriting?

While researching this, I discovered something fascinating. They actually cannot have the exact same signature because a signature, or even handwriting, is often called the brain's fingerprint. Research also suggests that even the same person cannot write the exact same signature twice. Natural variations in muscle movement, writing speed, and hand control mean that every signature is slightly different. If two signatures look 100% identical, one of them is most likely a copied forgery or a printed copy because the human hand cannot reproduce the exact same motion with absolute precision.

That discovery inspired me to build AuthentiSign, an AI-powered project that identifies forged signatures using a Kaggle dataset.

Many organisations, such as banks, prosecution services, national forensic services, and national tax services, rely on signatures for identity verification. However, signatures can be forged quite easily. Studies estimate that the rate of signature forgery is around 8% to 12%, yet there simply aren't enough forgery detection specialists to verify every suspicious signature.

That made me think, why not let AI help fill that shortage? If a machine learning model can learn from thousands of genuine signatures as well as forged ones, it may be able to identify subtle patterns that help distinguish between authentic and forged signatures, making the verification process faster and more reliable.

And it's not just limited to banks or forensic investigations. Signature verification is also important in security, medical diagnosis, smart factories, and even self-driving cars, where signatures are used to verify the authenticity and integrity of software, firmware, devices, and digital communications. That's why I believe AI can play an important role in making these systems more secure and trustworthy.

What it does

AuthentiSign is an AI-powered signature verification system that helps distinguish between genuine and forged signatures.

A user uploads a reference signature and a signature that needs to be verified. The system preprocesses both images, analyses them using a deep learning model, compares their similarity, and predicts whether the signature is genuine or forged. Along with the prediction, it also provides a confidence score to help users better understand the result.

The project is designed to demonstrate how AI can assist industries that rely heavily on signature verification, including banking, forensic investigations, cybersecurity, healthcare, smart manufacturing, and autonomous systems.

How we built it

To build AuthentiSign, I used the CEDAR signature dataset, which contains both genuine and forged signatures for training and evaluation.

Instead of building a traditional classification model, I chose a Siamese Neural Network because signature verification is fundamentally a similarity problem rather than an identity classification problem. The model learns to compare two signatures and determine how similar they are instead of memorising specific people's signatures.

The preprocessing pipeline converts signatures to grayscale, resizes them, applies thresholding and normalization, and then feeds both signatures into the Siamese network. The network generates feature embeddings for each signature, calculates the distance between them, and compares that distance against a tuned threshold to determine whether the signatures are genuine or forged.

To make the project usable, I built a complete web application using React, Vite, and Tailwind CSS for the frontend, Flask for the backend API, TensorFlow/Keras for the deep learning model, and JWT authentication to securely access protected verification features.

Challenges we ran into

One of the biggest challenges was that genuine signatures are never identical. Every person's signature naturally changes slightly because of variations in writing speed, pressure, and hand movement. Teaching the model to recognise these natural variations while still detecting actual forgeries was one of the most difficult parts of the project.

Beyond the machine learning model, making the entire application reliable was another major challenge. During development, I encountered issues such as missing model files, dataset dependencies, inconsistent backend ports, Python import problems, stale development processes, and ensuring that the project worked correctly from a completely fresh clone rather than only on my own machine. Solving these problems taught me the importance of reproducibility, clean project structure, and thorough end-to-end testing.

Accomplishments that we're proud of

I'm proud that AuthentiSign goes beyond being just a trained machine learning model. It is a complete end-to-end application that combines AI, backend development, frontend development, authentication, and an intuitive user interface into a single working system.

More importantly, I'm proud that the project addresses a real-world problem. Signature forgery affects financial institutions, legal organisations, and many other industries, and AuthentiSign demonstrates how AI can assist experts by making the verification process faster and more reliable.

I'm also proud of building a project that can be reproduced and demonstrated reliably, making it easier for others to clone, run, and evaluate.

What we learned

Building AuthentiSign taught me much more than training a deep learning model.

I learned how Siamese Neural Networks work for similarity learning, how preprocessing directly impacts model performance, and why choosing the right architecture matters more than simply selecting a complex model.

I also gained valuable experience integrating machine learning into a full-stack application, designing REST APIs, implementing authentication, debugging integration issues between the frontend and backend, and making the project reproducible for anyone who wants to run it.

Most importantly, I learned that building a successful AI application is not just about achieving good model accuracy—it's about creating a complete, reliable system that solves a real-world problem.

What's next for authentisign

This is only the beginning for AuthentiSign.

In the future, I plan to improve the model by training on larger and more diverse datasets to make it more robust across different handwriting styles and signature variations.

I also plan to add features such as explainable AI to highlight why a signature was classified as genuine or forged, support for document-level verification, cloud deployment for easier accessibility, persistent storage for verification history, and stronger security features suitable for production environments.

My long-term vision is for AuthentiSign to become an intelligent AI assistant that helps organisations perform secure, accurate, and scalable signature verification across banking, forensics, cybersecurity, healthcare, smart factories, and other industries where trust and authenticity are critical.

Built With

• computer-vision
• css
• deep-learning
• flask
• javascript
• jwt
• keras
• machine-learning
• numpy
• opencv
• python
• react
• scikit-learn
• tailwind
• tensorflow
• vite