DEV Community: Akhouri Anmol Kumar

I Trusted My Own Encryption Until GitHub Copilot Called It "Weak"

Akhouri Anmol Kumar — Fri, 24 Jul 2026 12:09:39 +0000

I Trusted My Own Encryption... Until I Realized It Wasn't Good Enough.

A few weeks ago, I thought the password vault inside my Windows security project was "secure."

It worked.

It stored passwords.

It encrypted data.

Everything looked fine.

Then I stepped back and asked myself a simple question:

"If I were reviewing this as a security engineer instead of its developer, would I actually trust it?"

The answer was no.

So I deleted it.

🧠 The Biggest Mistake Developers Make

Many beginner security projects confuse encoding, hashing, and encryption.

If your application simply transforms text and stores it, that doesn't automatically make it secure.

Real security is about key management, attack resistance, and well-tested cryptographic primitives—not just making data unreadable at first glance.

❌ My Old Mental Model

Password
│
▼
"Encrypt"
│
▼
Store

✅ What I Wanted Instead

Master Password
│
▼
PBKDF2-HMAC-SHA256
(200,000 iterations)
│
▼
Derived Key
│
▼
Fernet Encryption
│
▼
Encrypted Vault
🔄 Sometimes the Best Upgrade Is Deleting Your Own Code

The hardest part wasn't writing new code.

The hardest part was accepting that my previous implementation wasn't good enough.

As developers, we naturally become attached to code we've spent hours building.

Security doesn't care how long something took to write.

If there's a better approach, rewrite it.

🔒 While Building ATLOCK v4...

I redesigned the password vault around a few principles:

PBKDF2-HMAC-SHA256 for key derivation
200,000 iterations to increase resistance against brute-force attacks
Fernet authenticated encryption for encrypted vault data
Local-only storage
No plaintext password storage

ATLOCK still isn't "perfect"—and I don't think any security software should claim to be.

But it's significantly stronger than where it started.

Version 1

"Works."

    │

    ▼

Version 2

"Looks Secure."

    │

    ▼

Version 3

"Actually Follows Better Security Practices."
💭 One Lesson I'll Keep With Me

Building security software taught me something I didn't expect.

Writing secure code isn't about proving your first design was correct.

It's about having the humility to delete it when you discover a better one.

Sometimes the biggest security improvement isn't a new algorithm.

It's admitting your previous implementation wasn't good enough.

I'd love feedback from other developers.

If you've ever rewritten an entire feature because you realized the original design was flawed, what was it?
Try ATLOCK v4-https://github.com/Akhouri-Anmol-Kumar/ATLOCK
ATLOCK is made under Akhouri systems.

"We Build What Others Forgot To Fix"

🔒 Why ATLOCK v4 Is Different: Engineering a Security Suite Instead of Just Another Password Locker

Akhouri Anmol Kumar — Fri, 24 Jul 2026 10:34:23 +0000

"The biggest mistake in desktop security is assuming a password is enough."

That single thought became the foundation of ATLOCK v4.

I didn't want to build another application that asks for a password and calls itself "secure."

I wanted to build something that responds, detects, records, and defends.

🧠 Security Isn't One Feature

Many desktop security apps look like this:

Open App
│
▼
Enter Password
│
▼
Access Granted / Denied

ATLOCK v4 is designed differently.

Authentication
│
▼
Intrusion Detection
│
▼
Evidence Collection
│
▼
Notification
│
▼
System Lockdown

A failed authentication isn't just "wrong password."

It's a security event.

🏗 Layered Architecture

Instead of putting everything inside one huge file, every subsystem has a dedicated responsibility.

             ATLOCK v4

    ┌──────────────────────┐
    │   Lockdown Engine    │
    └──────────┬───────────┘
               │
┌──────────────┼──────────────┐
▼              ▼              ▼

File Guard Password Vault Intruder Engine

│              │              │

NTFS ACL Fernet Crypto Camera System

└──────────────┼──────────────┘
               ▼

      Notification Manager

This modular design makes the project easier to debug, extend, and maintain.

🔐 Real Cryptography

Security software shouldn't rely on homemade encryption.

ATLOCK v4 uses:

Master Password
│
▼
PBKDF2-HMAC-SHA256
(200,000 iterations)
│
▼
Derived Encryption Key
│
▼
Fernet Encryption
│
▼
Encrypted Vault

The goal wasn't to invent cryptography—it was to use well-established building blocks correctly.

🛡 Working With Windows Instead of Around It

Many applications simply:

hide folders
rename files
change attributes

ATLOCK instead leverages Windows security mechanisms where appropriate.

Application
│
▼
Windows Security APIs
│
▼
NTFS Access Control Lists
│
▼
Access Restricted

Using operating system features provides stronger protection than cosmetic hiding techniques.

📸 Intrusion Detection

Most applications do this:

Wrong Password

↓

Try Again

ATLOCK treats repeated failures as a sequence of events.

Wrong Password

↓

Photo Capture

↓

Notification

↓

Repeated Attempts

↓

Video Recording

↓

Alarm

↓

Lockdown

The idea is to create visibility into suspicious activity rather than simply rejecting access.

🧵 Responsiveness Matters

Security software often performs multiple operations simultaneously:

encryption
camera capture
notifications
monitoring
UI rendering

Running everything on the main thread would make the application feel sluggish.

Instead, background workers handle long-running tasks while the interface remains responsive.

🔔 Logging Without Exposing Secrets

Logs are useful.

Sensitive data isn't.

ATLOCK stores metadata like:

✓ Timestamp

✓ Event Type

✓ Device Information

✓ Evidence

✓ Result

But avoids recording plaintext passwords.

Even diagnostic information should follow the principle of least exposure.

🧩 Designed for Failure

One engineering lesson I learned:

Every dependency eventually fails.

Instead of crashing when an optional component isn't available, ATLOCK attempts to degrade gracefully.

Camera Available?
│
┌────┴────┐
│ │
Yes No
│ │
Capture Continue

Security shouldn't disappear because one module couldn't initialize.

💡 What Makes ATLOCK v4 Special?

Not because it has the most features.

Not because it claims to be "unbreakable."

But because every feature contributes to one design philosophy:

Security should be layered, observable, and resilient—not just password protected.

🚀 What's Next?

Current areas I'm exploring:

Hardware security key support
Argon2 for key derivation
Secure cloud synchronization
Signed update mechanism
Plugin architecture
Improved cross-platform compatibility
Final Thoughts

ATLOCK v4 isn't intended to replace enterprise endpoint security or antivirus platforms.

It's an engineering project focused on combining modern cryptography, Windows security features, event-driven intrusion handling, and modular software architecture into a cohesive desktop application.

Building it has taught me that good security isn't about one clever feature—it's about how multiple layers work together.
🔗GitHub: https://github.com/Akhouri-Anmol-Kumar/ATLOCK
🔗Directly Download ATLOCK & Try it: https://github.com/Akhouri-Anmol-Kumar/ATLOCK/releases/download/v4.0/ATLOCK.zip

"We Build What Others Forgot To Fix"

🔒 How I Built ATLOCK v4 — A Deep Technical Breakdown of a Windows Security Suite

Akhouri Anmol Kumar — Thu, 23 Jul 2026 14:52:49 +0000

"I didn't want to build another password locker.

I wanted to build something that reacts to attacks."

Most desktop security applications follow a simple pattern.

Password

↓

Unlocked

I wanted something different.

Authentication

↓

Detection

↓

Evidence Collection

↓

Notification

↓

Escalation

↓

Lockdown

That idea eventually became ATLOCK v4.

🚀 The Goal

Instead of protecting one thing, I wanted multiple security layers working together.

The final system combines:

✅ File Protection

✅ Password Vault

✅ Intruder Detection

✅ Camera Evidence

✅ Windows Lockdown

✅ Notification Engine

All inside one desktop application.

🏗 System Architecture
ATLOCK v4

        ┌──────────────────────────┐
        │      Lockdown Engine      │
        └─────────────┬────────────┘
                      │
    ┌─────────────────┼─────────────────┐
    ▼                 ▼                 ▼

File Guard Password Vault Intruder Engine

    │                 │                 │

 NTFS ACL       Fernet Crypto      OpenCV Camera

    │                 │                 │

    └─────────────────┼─────────────────┘
                      ▼

          Notification Manager

Every module has exactly one responsibility.

That made debugging much easier than maintaining a single massive file.

🔐 Challenge #1
Passwords Should Never Be Stored

The first design decision was simple.

Passwords should never exist as plain text.

Pipeline:

Master Password

↓

PBKDF2-HMAC-SHA256

↓

200,000 Iterations

↓

Derived Key

↓

Fernet Encryption

↓

Encrypted Vault

Why?

Because even if someone steals the encrypted vault, they still can't read its contents without the correct key.

🛡 Challenge #2
File Protection

Many "file lockers"

rename files
hide folders
change icons

That isn't real protection.

Instead, ATLOCK works directly with Windows.

Application

↓

Windows Security

↓

NTFS Access Control Lists

↓

Access Denied

When ACLs aren't available, the application gracefully switches to an alternative protection method.

📸 Challenge #3
Turning Failed Passwords into Security Events

Instead of

Wrong Password

↓

Try Again

I built

Wrong Password

↓

Capture Photo

↓

Send Notification

↓

More Attempts

↓

Record Video

↓

Alarm

↓

System Lockdown

Authentication became an event pipeline instead of a boolean check.

⚙ Challenge #4
Keeping the UI Responsive

Running

camera
encryption
monitoring
alarms

on the main thread would freeze the interface.

So I separated long-running operations into background workers.

UI Thread

│

├── Camera Thread

├── Alarm Thread

├── Notification Thread

└── Monitoring Thread

The application remains responsive while security operations continue independently.

🔔 Challenge #5
Logging Without Leaking Information

One mistake many applications make is storing sensitive logs.

ATLOCK never records plaintext passwords.

Instead it stores

Attempt

↓

Timestamp

↓

Masked Password

↓

Photo

↓

Video

↓

Result

Example

********** (10 chars)

instead of

SuperSecret123

Even logs should follow the principle of least exposure.

🧩 Design Philosophy

Rather than asking

"Can I stop every attacker?"

I asked

"Can I make every attack visible?"

That completely changed the architecture.

Security became

Detect

↓

Record

↓

Respond

↓

Recover

instead of

↓

Reject
🛠 Tech Stack
Python

↓

PyQt

↓

OpenCV

↓

Cryptography

↓

Windows API

↓

NTFS ACL

↓

Threading

↓

JSON Configuration

Each technology solved one specific problem.

📊 Lessons Learned

Building ATLOCK v4 taught me:

✔ Security isn't one feature.

✔ Cryptography alone isn't enough.

✔ UX matters in security software.

✔ Modular architecture scales better.

✔ Logging is part of security.

✔ Defensive programming saves hours of debugging.

🚀 What's Next

The roadmap includes:

Hardware security key support
Secure cloud synchronization
Plugin system
Argon2-based key derivation
Cross-platform backend
Signed updates
Final Thoughts

ATLOCK v4 isn't trying to replace enterprise endpoint security or antivirus software.

Its goal is different: explore how multiple independent security layers—cryptography, operating system features, event-driven detection, and forensic logging—can work together inside a desktop application.

That journey taught me far more about software engineering than simply building another password manager ever could.

ATLOCK v4 has been one of the most challenging and rewarding projects I've built, pushing me to learn Windows APIs, applied cryptography, concurrency, and defensive software design.
🔗ATLOCK on GitHub: https://github.com/Akhouri-Anmol-Kumar/ATLOCK
🔗Direct Download(ATLOCK): https://github.com/Akhouri-Anmol-Kumar/ATLOCK/releases/download/v4.0/ATLOCK.zip

ATLOCK is built by Akhouri Anmol Kumar Under Akhouri Systems
ATLOCK is akhouri systems flagship product but we have built more 3 apps.
Try Them Too! to be the part of the akhouri systems ecosystem
APIC(image edition tool)-https://github.com/Akhouri-Anmol-Kumar/APIC
ACALCU v3(world's most customizable calculator)-https://github.com/Akhouri-Anmol-Kumar/ACALCU-v3
ANOTE(a premium text editor with many features---The notepad killer)-
https://github.com/Akhouri-Anmol-Kumar/ANOTE

"We Build What others Forgot To Fix"

🔒 Should You Really Download ATLOCK v4?

Akhouri Anmol Kumar — Thu, 23 Jul 2026 10:07:12 +0000

An Honest Technical Review — Strengths, Weaknesses & Trade-offs

Every security software has strengths.

Every security software has weaknesses.

ATLOCK v4 is no exception.

Instead of pretending it's perfect, let's break it down like security engineers do.

⚡ TL;DR
Category Rating
Security Design ⭐⭐⭐⭐⭐
Cryptography ⭐⭐⭐⭐⭐
Windows Integration ⭐⭐⭐⭐⭐
UI ⭐⭐⭐⭐☆
Performance ⭐⭐⭐⭐☆
Portability ⭐⭐☆☆☆
Enterprise Ready ⭐⭐☆☆☆
Overall 9.1/10
🏗 Architecture
ATLOCK v4

  ┌──────────────────────────────┐
  │      Lockdown Engine         │
  └──────────────┬───────────────┘
                 │
 ┌───────────────┼────────────────┐
 ▼               ▼                ▼

File Guard Password Vault Intruder Ops

 │               │                │

NTFS ACL AES Encryption Camera Engine

 │               │                │

 └───────────────┼────────────────┘
                 ▼

      Notification Manager

Instead of becoming one giant security application, every feature exists as an independent module.

That makes maintenance significantly easier.

✅ Strength #1 — Layered Security

Most desktop lockers work like this

Password

↓

Unlocked

ATLOCK works differently.

Wrong Password

↓

Photo

↓

Notification

↓

Alarm

↓

Video

↓

Hard Lock

Authentication is only the beginning.

Every failure becomes a security event.

✅ Strength #2 — Real Cryptography

One thing many hobby security applications get wrong is encryption.

Common examples include

XOR
Base64
Caesar Cipher
Homemade algorithms

ATLOCK instead uses

PBKDF2-HMAC-SHA256

↓

200,000 iterations

↓

Derived Key

↓

Fernet Encryption

↓

Encrypted Vault

That immediately places it above a huge number of beginner password managers.

✅ Strength #3 — Windows Native Security

Rather than hiding files,

ATLOCK interacts with Windows itself.

Application

↓

Windows Security API

↓

NTFS ACL

↓

Access Denied

Using operating system permissions is significantly stronger than simply renaming files.

✅ Strength #4 — Defensive Programming

Throughout the project you'll notice lots of

✔ graceful fallbacks

✔ optional dependencies

✔ background workers

✔ exception logging

Instead of crashing when OpenCV isn't installed...

the application simply disables camera features.

✅ Strength #5 — Event Driven Security

Authentication isn't treated as binary.

Instead

Attempt #1

↓

Photo

↓

Attempt #2

↓

Warning

↓

Attempt #3

↓

Video

↓

Alarm

↓

Hard Lock

That's closer to how real security systems behave.

✅ Strength #6 — Clean Separation

Instead of

security.py

containing 5000 lines...

ATLOCK separates responsibilities.

Lockdown

Vault

Notifications

Camera

Sound

Settings

File Guard

That makes future upgrades significantly easier.

❌ Weakness #1 — Windows Only

This is probably the biggest limitation.

Features like

NTFS ACL
Windows Hooks
LockWorkStation
Win32 APIs

are Windows specific.

Linux users lose much of the security stack.

❌ Weakness #2 — Python Distribution

Python applications usually become

Large Executable

↓

Many Dependencies

↓

Longer Startup

Compared to

Rust
C++
Go

the executable size is larger.

❌ Weakness #3 — Local Security Only

ATLOCK currently focuses on one machine.

Missing features include

Cloud Sync
Remote Device Management
Multi-device Vault
Secure Backup
❌ Weakness #4 — Recovery Trade-off

The current design intentionally includes an owner recovery mechanism.

That's convenient for the owner, but any recovery path is also a trade-off because it increases the attack surface if distributed widely.

❌ Weakness #5 — Not Enterprise Software

ATLOCK is designed as a desktop security application.

It doesn't currently include

Active Directory integration
Enterprise policy management
Audit servers
Centralized logging
Compliance features
📊 Security Philosophy

Traditional software

Password

↓

Access

ATLOCK

Authentication

↓

Detection

↓

Evidence

↓

Notification

↓

Escalation

↓

Lockdown

That layered approach is arguably its strongest engineering decision.

📈 Where ATLOCK Performs Best
Scenario Rating
Personal Laptop ⭐⭐⭐⭐⭐
Student Device ⭐⭐⭐⭐⭐
Developer Machine ⭐⭐⭐⭐☆
Office PC ⭐⭐⭐⭐☆
Enterprise Fleet ⭐⭐☆☆☆
Linux Systems ⭐☆☆☆☆
💡 Who Should Download It?
✅ Good Fit

✔ Students

✔ Developers

✔ Windows users

✔ Privacy enthusiasts

✔ People wanting local password storage

✔ Users interested in intrusion monitoring

❌ Not Ideal

✖ Large enterprises

✖ Cross-platform users

✖ Teams needing cloud synchronization

✖ Users expecting antivirus or endpoint detection capabilities

Final Verdict

Would I recommend downloading ATLOCK v4?

Yes—with the right expectations.

If you're looking for a Windows-focused desktop security suite that combines password protection, file guarding, cryptography, intrusion detection, and layered defensive mechanisms in a single application, ATLOCK v4 offers an interesting implementation.

If you need enterprise fleet management, cloud synchronization, or cross-platform support, it's not there yet.

The project's strongest point isn't that it claims to be "unbreakable." It's that it applies multiple, independent security layers instead of relying on a single password prompt.

⭐ Final Score
Security Design ⭐⭐⭐⭐⭐
Cryptography ⭐⭐⭐⭐⭐
Windows Integration ⭐⭐⭐⭐⭐
Architecture ⭐⭐⭐⭐⭐
Performance ⭐⭐⭐⭐☆
Portability ⭐⭐☆☆☆
Enterprise Features ⭐⭐☆☆☆
Ease of Use ⭐⭐⭐⭐☆

Overall Rating: ⭐ 9.1 / 10

🔗 GitHub : https://github.com/Akhouri-Anmol-Kumar/ATLOCK
🔗 Direct Download(ATLOCK): https://github.com/Akhouri-Anmol-Kumar/ATLOCK/releases/download/v4.0/ATLOCK.zip

"We Build What Other Forgot To Fix"

🔒 Inside ATLOCK v4: Building a Windows Security Suite Beyond Simple Password Protection

Akhouri Anmol Kumar — Wed, 22 Jul 2026 16:05:53 +0000

Most "file lockers" are just password gates.

I wanted something different.

Something that combines OS-level security, cryptography, intrusion detection, forensic logging and system lockdown into one desktop application.

⚡ What is ATLOCK v4?

ATLOCK v4 is a Python-based Windows security suite designed around a simple philosophy:

Security shouldn't stop after asking for a password.

Instead, every failed authentication becomes an event that triggers multiple independent security layers.

Wrong Password
│
▼
Intruder Detection
│
┌─────┴────────┐
│ │
Photo Video
│ │
▼ ▼
Notifications Logging
│
▼
Security Escalation
🧩 Architecture
ATLOCK v4

    ┌────────────────────────────┐
    │      Lockdown Engine        │
    └────────────┬───────────────┘
                 │
  ┌──────────────┼──────────────┐
  ▼              ▼              ▼

File Guard Password Vault Intruder Ops

  │              │              │

NTFS ACL Fernet AES Camera Engine

  │              │              │
  └──────────────┼──────────────┘
                 ▼
         Notification Engine

Instead of making one giant security module, every subsystem is isolated.

That means:

easier debugging
easier upgrades
less coupling
independent security layers
🔐 1. Real Cryptography (No XOR Tricks)

One thing I wanted to eliminate completely was fake encryption.

Many hobby projects still rely on:

XOR
Caesar shifts
Base64
homemade encryption

ATLOCK v4 instead uses

✅ PBKDF2-HMAC-SHA256

200,000 iterations

for password derivation.

Then derives a Fernet key.

Finally encrypts vault entries using authenticated encryption.

Password

│

PBKDF2-HMAC-SHA256
200,000 rounds

│

Derived Key

│

Fernet AES Encryption

│

Encrypted Vault

This means tampering with encrypted vault data is detected automatically.

🛡️ 2. File Guard Uses Windows ACLs

Instead of hiding files...

Instead of renaming files...

ATLOCK actually interacts with Windows security.

It modifies NTFS Access Control Lists.

User

│

Open File

│

Windows ACL

│

Access Denied

If native APIs aren't available, it gracefully falls back to an alternate protection method.

That fallback makes the software more portable without sacrificing functionality.

🚨 3. Intruder Detection is Event Driven

Authentication failure doesn't simply increase a counter.

Instead every event escalates.

Wrong Password #1

↓

Photo Capture

↓

Notification

↓

Wrong Password #3

↓

10 Second Video

↓

Alarm

↓

Hard Lock

This creates an actual intrusion timeline instead of merely rejecting authentication.

🎥 4. Forensic Evidence Collection

ATLOCK automatically captures:

📸 timestamped photographs

🎥 timestamped videos

These are stored separately inside dedicated directories for later inspection.

Rather than overwriting evidence, each capture receives a unique timestamp and random identifier.

🔔 5. Security Notifications

Another small feature I enjoyed building was the notification system.

Every security event becomes structured metadata.

Event

↓

Timestamp

↓

What level is ATLOCK v4 actually at? An honest self-audit.

Akhouri Anmol Kumar — Wed, 22 Jul 2026 11:20:59 +0000

🎚️ What Level Is ATLOCK v4 Actually At?

TL;DR — Not "finished." Not "toy project" either. Somewhere in the middle, and here's an honest breakdown of exactly where, feature by feature — including what's genuinely solid and what still needs work.

Most launch posts only show the highlight reel. This one's different — a real self-audit of where ATLOCK v4 stands right now, graded feature by feature.

🔒 System Lockdown — Production-grade

Low-level WH_KEYBOARD_LL hook, background watchdog killing Task Manager instantly, full input blocking. This has been battle-tested the most (including on myself, more than once). Solid.

🛡 File Guard — Advanced, still hardening

NTFS ACL manipulation at the OS permission layer — not a password wrapper. This is the most technically ambitious part of the project. Handle-lifecycle edge cases (already-open handles surviving an ACL change) are handled, but I wouldn't call this "battle-tested at scale" yet — it's been through my own extensive testing, not thousands of real-world environments.

🔑 Password Vault — Rebuilt, cryptographically sound

AES (Fernet) + PBKDF2-HMAC-SHA256, 200,000 iterations. This is a real jump from v3's weak encoding scheme. The cryptography itself is standard and correct — I'm not rolling my own crypto, which is the right call at this stage.

📸 Intruder Ops — Functional, room to grow

Photo/video capture on failed attempts works reliably. What it doesn't have yet: any kind of ML-based false-positive filtering, or configurable sensitivity. It's a binary trigger right now, and that's fine for v4 — but it's not "smart" yet.

🌐 Distribution & Trust — Early-stage

No code signing yet (application submitted, pending review). No installer, no auto-update mechanism. This is the area furthest from "mature" — right now, trust is built entirely through transparency (open source, independent reviews) rather than infrastructure (signing, verified publisher status).

📊 The Honest Scorecard
Component Level
System Lockdown Production-grade
File Guard Advanced, hardening in progress
Password Vault Cryptographically sound
Intruder Ops Functional, not yet "smart"
Distribution/Trust infra Early-stage
🧭 What "done" would actually look like
Code-signed builds (in progress)
Auto-update mechanism
Broader real-world testing of File Guard across more NTFS configurations
Optional local-only usage analytics to know which features actually retain users, without any data leaving the device

None of that exists yet. ATLOCK v4 is real, working software — not a demo — but it's also not a finished product, and I'd rather say that directly than let the marketing outrun the code.

Why post this instead of just the highlight reel

Because the version of this post that only lists strengths is indistinguishable from every other launch post, and this one isn't trying to be that. If you're evaluating whether to actually rely on this for something that matters, you deserve the real breakdown, not just the parts that sound impressive.

🔗 GitHub: https://github.com/Akhouri-Anmol-Kumar/ATLOCK
🔗 Direct Download ATLOCK: https://github.com/Akhouri-Anmol-Kumar/ATLOCK/releases/download/v4.0/ATLOCK.zip

If you've shipped something similar, where would you draw your own line between "solid" and "production-grade"? Genuinely curious where others set that bar.

"We Build What Other Forgot To Fix"

🏗️ Akhouri Systems: 4 apps, 1 thirteen-year-old kid, 0 employees

Akhouri Anmol Kumar — Tue, 21 Jul 2026 11:03:52 +0000

No co-founder. No funding. No backend team. Just a laptop, a lot of failed builds, and a name I gave myself: Akhouri Systems.

Here's everything I've shipped so far — and what I actually learned building it.

🔒 ATLOCK — the flagship

A Windows security suite that does what most "lock" apps fake:

System Lockdown — real OS-level enforcement, blocks Alt+Tab, Win key, kills Task Manager on sight
File Guard — locks files using NTFS Access Control Lists, the same permission layer Windows itself enforces. Not even admin access bypasses it
Password Vault — AES + PBKDF2-HMAC-SHA256 encrypted, fully local, zero cloud
Intruder Ops — auto-captures a photo + video the moment someone enters the wrong password

It's fully offline. Independently reviewed and certified "100% Clean" by Softpedia.

📝 ANOTE

A multi-tab text editor with a built-in translator and a lock screen — built because I wanted a Notepad replacement that didn't feel like it was designed in 2005.

🧮 ACALCU

A fully customizable calculator. My first product — the one that started Akhouri Systems.

📷 APIC

A local image processing tool — no cloud upload required to edit or process images.

🧭 What building this alone actually taught me

Every dependency is a dependency I maintain, forever, alone. That's the real reason ATLOCK doesn't have a server, a dashboard, or a subscription. Fewer moving parts means fewer things breaking with no team to catch it.

The hardest technical problem wasn't UI, it was NTFS ACLs. Getting Windows' own permission system to actually enforce a file lock — instead of faking it with a password dialog — meant working directly with the Win32 security API. Getting the save/restore cycle for permissions exactly right took the most iteration of anything I've built.

Shipping solo means every bug is mine, immediately. No triage meeting, no assigning tickets — if something breaks, I'm the one who finds out and the one who fixes it. That's been the fastest way to actually learn how software behaves in the real world instead of just how it's supposed to.

📊 Where things stand
415+ downloads, zero ad spend
Listed on Softpedia, SourceForge, AlternativeTo, IndiAlt
All builds free, open source, single .exe — no installer, no subscription
Why I'm sharing this

I don't think age should be the reason to wait before building something real. If you're young and think you're "too early" to ship — you're probably not. Start now, ship something small, and keep going.

🔗 GitHub: https://github.com/Akhouri-Anmol-Kumar
🔗 ATLOCK specifically: https://github.com/Akhouri-Anmol-Kumar/ATLOCK
🔗 Direct Download Link (ATLOCK) : https://github.com/Akhouri-Anmol-Kumar/ATLOCK/releases/download/v4.0/ATLOCK.zip

Would love feedback from this community — technical or otherwise. What should I build or fix next?

"We Build What Other Forgot To Fix"

How ATLOCK v4 actually Locks Files at the OS level (A technical breakdown)

Akhouri Anmol Kumar — Mon, 20 Jul 2026 11:38:37 +0000

🔐 How ATLOCK's File Guard Actually Works

TL;DR — Most "file lock" apps just hide a file or wrap it in a password check that anyone determined enough can route around. ATLOCK's File Guard instead manipulates NTFS Access Control Lists (ACLs) directly — the same permission layer Windows itself enforces. Here's how that actually works under the hood.

I promised a technical follow-up on this after a few people asked how File Guard is different from typical "lock" utilities. Here it is.

🧱 The Problem With Most File Lockers

The typical approach:

Rename the file / hide the extension
Store a password somewhere
Check the password before "unlocking" (i.e., renaming it back)

This isn't real protection. Anyone with basic file system access — or malware running with the same user permissions — can bypass it entirely. It's a UI-level lock on top of a file system that never actually enforced anything.

🔧 What File Guard Does Differently

Windows already has a real permission system built in: NTFS Access Control Lists. Every file and folder on an NTFS volume has an associated security descriptor that defines exactly who can read, write, execute, or delete it — enforced by the OS kernel itself, not by any application sitting on top.

File Guard's job is to directly edit that security descriptor for a file so that no account — not even an administrator — has access, until ATLOCK explicitly restores it.

The rough flow:

User selects a file to guard
ATLOCK reads the file's current ACL (so it can be restored later)
ATLOCK strips/denies access for all relevant SIDs (Security Identifiers) on that file — including the owning user and Administrators group
The file is now inaccessible at the OS level — Explorer, command line, other processes, all get "Access Denied"
On unlock, ATLOCK restores the original ACL exactly as it was 🪟 Why This Is Harder Than It Sounds

A few things that made this genuinely tricky to get right:

Permission escalation for the operation itself. Editing a file's ACL is itself a privileged operation — the process doing the editing needs the right token privileges (SeRestorePrivilege / SeTakeOwnershipPrivilege in some cases) to override existing restrictions, even temporarily.

Not breaking the "restore" step. If you strip an ACL and don't store the exact original security descriptor first, you can permanently corrupt a file's permissions — including locking out the legitimate owner forever. Getting the save/restore cycle bit-for-bit reversible took the most iteration.

Avoiding ACL inheritance leaks. Windows permissions can inherit down to child objects and open handles. If a process already has a file handle open when you change the ACL, that handle may still work until it's closed — meaning the "lock" only takes effect for new access attempts unless you also handle already-open handles.

Doing this without requiring the user to run as full admin at all times. Ideally you don't want a security tool that demands admin rights just to exist in the background — so the privilege elevation needs to be scoped tightly to the moment it's actually needed.

🧰 The Tools Involved

All of this happens through the Win32 security API — there's no high-level Python library that does this safely out of the box. It means working directly with:

SetNamedSecurityInfo / GetNamedSecurityInfo for reading and writing security descriptors
Security Identifiers (SIDs) to correctly target the right accounts
Careful privilege token handling to perform the operation without over-broadening what the app can touch
🔒 The End Result

A file that's genuinely inaccessible — Explorer shows "Access Denied," del fails, copy fails, even a second admin account can't touch it — until ATLOCK restores the original permissions. That's a structurally different guarantee than a password dialog sitting on top of an otherwise-open file.

Where this fits in ATLOCK v4

File Guard is one piece of the broader suite — alongside System Lockdown, an AES-encrypted Password Vault (rebuilt from scratch in v4 with PBKDF2-HMAC-SHA256), and Intruder Ops (automatic photo/video capture on failed access attempts). v4 also removed every cloud dependency the app had — it's fully offline now.

🔗 GitHub: https://github.com/Akhouri-Anmol-Kumar/ATLOCK
🔗 Website: https://akhouri-anmol-kumar.github.io/Akhouri-systems/

If you've worked with NTFS ACLs or Win32 security APIs before, I'd genuinely like to compare notes — this was the single hardest part of the whole project, and I'm sure there are edge cases I haven't hit yet.

"We Build What Other Forgot To Fix"

How Akhouri Systems crossed 400 downloads with zero dollar spend

Akhouri Anmol Kumar — Sun, 19 Jul 2026 06:23:54 +0000

🚀 400 Downloads. $0 Spent. Here's the Exact Breakdown.

TL;DR — No ads, no PR agency, no paid promotion. Just specific, honest, cross-platform posting, one external "100% Clean" certification, and a refusal to oversell. Here's exactly what moved the needle, in order of impact.

Akhouri Systems started with nothing — no audience, no mailing list, no existing following. Just a GitHub account, a Windows security suite called ATLOCK, and enough confidence in the product to put it in front of strangers.
Here's what actually happened.

📊 The Starting Point
Day 1Audience0Ad budget $0 Team1 (me)Funding ₹0Product ATLOCK — a Windows security suite, single .exe, offline-first

🎯 What Actually Moved the Needle
1️⃣ Specificity beats enthusiasm, every time
Every post that worked wasn't "check out my app" — it was a verifiable technical claim:

NTFS ACL-level file locking that even admin can't bypass. AES + PBKDF2 vault encryption, 200,000 iterations.

Developers can smell vague marketing copy from a mile away. Real numbers and real mechanisms are the entire trick.
2️⃣ Same product, three different posts
The same copy-pasted paragraph across every platform reads as spam — even when it's not. So:
Platform Angle dev.to Technical breakdown, deep detail Peerlist Short, personal, punchy LinkedIn Credibility-first, professional tone
3️⃣ Admitting weaknesses on purpose
One of the highest-engagement posts I wrote was a direct ATLOCK vs. commercial security software comparison — including an honest section on where commercial tools still win (malware detection, official support, code-signing).

Nobody trusts a post that claims to be perfect. Naming the weaknesses bought more credibility than it cost.

4️⃣ Independent validation compounds differently
Getting listed on Softpedia mattered more than expected — not for raw traffic, but because a "100% Clean" certification and an independent 3.5/5 review from a party with zero stake in the outcome hits differently than another self-posted announcement.
5️⃣ Debugging in public, not hiding it
When the website's live download counter broke — twice — I didn't quietly patch it and move on. The debugging process itself became something worth being upfront about.

A product that visibly gets maintained, bugs and all, builds more trust than a static page that never changes.

🧭 If You're Starting From Zero

✅ Rewrite for the room — never post the identical paragraph on every platform
✅ Lead with your most falsifiable claim — vague enthusiasm doesn't convert, concrete mechanisms do
✅ State a real flaw on purpose — it buys more trust than it costs
✅ External validation compounds slower, but lasts longer than social posts
✅ Consistency > one big push — no single post crossed 400 downloads; a dozen honest ones did

🔭 What's Next
Working on the next ATLOCK release, and bringing ANOTE, ACALCU, and APIC — the other three products under Akhouri Systems — up to the same level of polish and visibility.
🔗 GitHub: https://github.com/Akhouri-Anmol-Kumar
If you're building solo and stuck at zero traction — drop it in the comments. What's actually worked for you?

Today(19 july, 2026) Akhouri Systems is standing at 417 downloads.
📈📈📈
"We Build What Other Forgot To Fix"

400+ downloads, 0 revenue, and why that's actually fine for now

Akhouri Anmol Kumar — Sat, 18 Jul 2026 10:53:21 +0000

400+ downloads. Still fully free. Here's where things stand.

ATLOCK crossed 400 downloads recently — no ad spend, no PR, just word slowly spreading. That's genuinely more validation than I expected this early.

The honest state of things

I'm not running this as a business yet, not really. There's no pricing tier, no premium version, no paywall anywhere. Everything — System Lockdown, File Guard, the encrypted vault, Intruder Ops — is fully free, and that's not changing anytime soon.

Building solo means every hour spent on this is an hour not spent on something else, and right now this runs entirely on personal time — no funding, no team, no revenue engine behind it.

Why I'm not rushing to monetize

A few reasons:

I'm 13, and setting up proper payment infrastructure (Stripe, Razorpay, etc.) needs an adult account holder — that's a "later, with my parents" conversation, not a "right now" one
I'd rather earn trust first than ask for money before the product has proven itself
A security tool asking for payment before it's established trust just feels backwards to me

The one thing that exists right now

The only way to support the project currently is a direct UPI tip on the website — genuinely optional, no features locked behind it, nothing changes if you don't. It's just there for anyone who wants to say "this was useful, here's something back."

Heads up: UPI only works for people banking in India, so this isn't something most of this community can actually use — that's just a limitation of where I'm starting from, not a choice to exclude anyone. If you're not in India, the best "support" is honestly just using the tool, starring the repo, or telling someone else about it.

What's next

Keep building, keep it free, keep listening to feedback. If a proper Pro tier or sponsorship model ever makes sense, it'll happen properly — with my parents involved in the business side of it, not as a rushed side feature.

🔗Website 👉 https://akhouri-anmol-kumar.github.io/Akhouri-systems/
🔗GitHub 👉 https://github.com/Akhouri-Anmol-Kumar

Curious how other solo/young builders here have thought about monetization timing — too early vs. too late is a real tension.

I'm 13, Solo Founder & CEO of Akhouri Systems. No team, no backend, no funding — just a laptop.

Akhouri Anmol Kumar — Sat, 18 Jul 2026 07:20:02 +0000

👋 I'm 13. I run a software company by myself.
No co-founder. No backend team. No investors. No support system beyond a laptop and a lot of trial and error.
Just me — building, breaking, and rebuilding — under a name I gave myself: Akhouri Systems.
This isn't a "look how young I am" post. It's a "here's what I actually shipped" post.

🏗️ The Setup

Team size: 1 (me)
Funding: ₹0
Infrastructure: none — everything ships as offline, standalone executables
Support system: Google, documentation, and a lot of failed builds

Everything below is real, working software — not prototypes, not concepts. Shipped, versioned, and public on GitHub.

🔒 ATLOCK — A Total Security Suite for Windows
The flagship product. Currently on v4.0.
What it does:

System Lockdown — locks the entire machine for a set duration; blocks Alt+Tab, the Win key, and kills Task Manager on sight via a low-level keyboard hook
File Guard — locks files at the NTFS Access Control List level, the deepest permission layer Windows exposes. A guarded file can't be opened, moved, or deleted by anyone — not even an admin
Password Vault — AES (Fernet) encryption with PBKDF2-HMAC-SHA256 key derivation (200,000 iterations), fully local storage
Intruder Ops — auto-captures a photo on the first wrong password attempt, a 10-second video on escalation, plus an audible alarm

What changed in v4: rebuilt the entire encryption layer from scratch, It's 100% offline — no accounts, no tokens, nothing leaves the machine.
This was also the hardest thing I've built. Getting NTFS ACLs to actually enforce permissions — instead of faking a lock with a password screen — meant working directly with Win32's security APIs.

📝 ANOTE — A Lightweight Multi-Tab Text Editor
Built because I wanted a notepad replacement that didn't feel like it was designed in 2005.

Multi-tab interface
Built-in multi-language translator
Password-protected lock screen
A meme canvas mode (because why not)

🧮 ACALCU — A Fully Customizable Calculator
Not just a calculator — a calculator you can actually make your own. Custom themes, layout control, and a polished UI instead of the default OS calculator experience.

📷 APIC — An Image Processing Tool
A utility for handling and processing images locally, without uploading anything to a cloud service to do it.

🧭 Why I'm Building Like This
I'm not waiting until I'm "old enough" to have opinions about software. Every one of these products started the same way: something annoyed me enough that I decided to just fix it myself instead of waiting for someone else to.
No team means every decision is mine — and every bug is also mine. No funding means every tool has to actually work, because there's no runway to hide behind. No backend means everything has to be genuinely self-contained, which is a harder constraint than it sounds.

🚀 Where to Find All of It
🔗 GitHub: https://github.com/Akhouri-Anmol-Kumar
🔗 ATLOCK specifically: https://github.com/Akhouri-Anmol-Kumar/ATLOCK
Everything is free, open, and documented. If you're curious how any of it works under the hood — the NTFS ACL implementation in ATLOCK especially — I'm happy to write a deeper technical breakdown if there's interest.
If you're young and building something, and you feel like you're "too early" to ship — you're probably not. Start now, ship something small, and keep going.
Would love feedback from this community, technical or otherwise. 🙏

"We Build What Other Forgot To Fix"

ATLOCK v4 vs. Typical Third-Party Security Software: What You're Actually Trading Off

Akhouri Anmol Kumar — Fri, 17 Jul 2026 07:38:09 +0000

🔒 ATLOCK v4 vs. Typical Third-Party Security Suites

TL;DR — Most "security suites" ask you to trust a company with your data, pay a subscription, and run background services you can't fully see into. ATLOCK is a single offline .exe: no account, no subscription, no telemetry, no cloud. Here's an honest breakdown of what you gain — and what you give up — going with something like ATLOCK instead of a typical commercial suite.

I'm not going to pretend ATLOCK beats a billion-dollar security company at every single thing. That would be dishonest, and dishonest comparisons age badly. What I can do is lay out, feature by feature, what's actually different — so you can decide what tradeoff makes sense for you.

🧩 The Core Philosophy Difference
Typical third-party security software is built to protect you from the internet — malware, phishing, network intrusions. That's genuinely valuable, and if that's your threat model, ATLOCK is not a replacement for antivirus software.
ATLOCK is built for a different problem entirely: physical/local access control. Someone picks up your laptop while you're away. Someone tries your files. Someone tries your vault. That's a threat model most mainstream suites treat as an afterthought — a login screen, maybe a "parental control" mode bolted on.

📊 Feature-by-Feature Breakdown
Typical 3rd-Party SuiteATLOCK v4InstallationInstaller + background services + auto-start agentsSingle portable .exe, nothing installedAccount requiredUsually yes (cloud dashboard, license management)No — zero accounts, zero sign-inInternet dependencyConstant — telemetry, cloud scanning, updatesNone — fully offline after downloadCost modelSubscription (often $30–80/year)FreeFile-level protectionRare, and usually just "encryption at rest"NTFS ACL-level lock — OS refuses access to anyone, including adminSystem lockdownNot typically offeredFull lockdown: Alt+Tab, Win key, Task Manager all blockedIntrusion responseUsually just a login failure logAuto photo on 1st wrong attempt, video + alarm on escalationData handlingScans/telemetry often sent to vendor serversNothing ever leaves your machineTransparencyClosed source, trust-the-vendor modelFully open on GitHub — read the code yourselfMalware/network protectionYes, this is their core strengthNo — not what ATLOCK is for

✅ Where ATLOCK Genuinely Wins
Zero cloud, zero trust required
You don't have to trust a company's servers, privacy policy, or breach history. There is no server. As of v4, ATLOCK doesn't even talk to Gmail or Telegram in the background anymore — it's fully self-contained.
Actual OS-level file locking
Most consumer "file lock" tools are cosmetic — they hide a file or wrap it in a weak password check that any determined user (or malware) can route around. ATLOCK's File Guard uses NTFS ACLs directly, the same permission layer Windows itself enforces. That's a structurally different guarantee.
No subscription, ever
Security software subscriptions are a real, recurring cost most people don't think about until renewal time. ATLOCK is free, and there's no dashboard trying to upsell you a "Premium" tier mid-scan.
You can read every line of the code
Closed-source security software asks for blind trust. ATLOCK's source is public — if you don't believe a claim in this post, go verify it yourself in the repo.

⚠️ Where a Typical Suite Still Wins — Be Honest About This

Malware/virus detection — ATLOCK does none of this. If you need antivirus, you still need antivirus.
Network/phishing protection — not ATLOCK's domain.
Enterprise support & SLAs — solo-dev project, not a support org.
Code-signing — ATLOCK isn't signed yet, so Windows SmartScreen will flag it (false positive, but it's friction a paid, signed product doesn't have).

If your threat model is "I need to not get owned by a phishing email," go get a real antivirus suite. If your threat model is "I need to lock down my machine and files when I step away, without a subscription or a cloud account," that's exactly the gap ATLOCK fills.

🧰 Under the Hood
Python core, CustomTkinter UI, OpenCV for intrusion capture, Cryptography (Fernet + PBKDF2-HMAC-SHA256, 200k iterations) for the vault, raw Win32 API for NTFS ACLs and low-level input hooks, packaged with PyInstaller into one portable file.

🚀 Try It Yourself

🔗 GitHub: https://github.com/Akhouri-Anmol-Kumar/ATLOCK
⬇️ Latest release: grab ATLOCK.zip from the Releases tab
ATLOCK v4 is free forever but to run a software company money is required, And for that I request you all if you are indian then support me on UPI
UPI id---7633003470@fam (10rupees, 100rupees, 1000rupees whatever you want. I just need support financially not numerically.)

Windows Defender may flag it as unrecognized — that's the standard unsigned-PyInstaller false positive, not malware. Click "More info" → "Run anyway."
If you've used a commercial lock/security tool and want to compare notes, drop it in the comments — I'd genuinely like to know what ATLOCK is still missing.

"We Build What Other Forgot To Fix"