Text sharing platforms are fundamental to modern software development workflows, enabling secure code sharing, documentation collaboration, and temporary data exchange. Zingat addresses the critical need for secure, ephemeral text storage in enterprise environments where data sensitivity and compliance are paramount.

The system enables users to create password-protected text snippets with configurable expiration dates, accessible through both web interface and command-line client. 

The platform handles text storage, retrieval, and analytics while maintaining enterprise-grade security and performance standards.

Engineering:

Web Framework & Database: Implemented using Rocket (Rust's web framework) and SQLX (async SQL toolkit), demonstrating modern async/await patterns and compile-time SQL verification. The system uses SQLite for data persistence with migration-based schema management, showcasing production database practices.

Concurrency & Performance: Leveraged Tokio runtime for async operations and implemented custom background processing for analytics, demonstrating advanced concurrency patterns essential for scalable web services.

System Architecture & Design: Clean separation between domain logic, data access, and web presentation layers using Domain-Driven Design principles. The modular structure includes dedicated modules for business logic, data persistence, and API endpoints, demonstrating enterprise-grade software organization.

Performance Optimization & Concurrency: A hit counter system using background threads and batched database operations. Instead of logging each view directly to the database, I defer operations to separate threads that batch multiple hits into single commits, significantly reducing database contention and improving response times.

API Design & Security: Comprehensive REST API with proper HTTP status codes, error handling, and API key authentication. The system includes both programmatic access via API keys and web-based access with cookie-based password authentication, demonstrating security-conscious API design.

Database Management & Migrations: Database schema management using SQLX migrations, ensuring version-controlled database evolution. The system handles complex data relationships and implements proper indexing for performance optimization.

Build Automation & DevOps: Complete build system with Cargo, including separate binaries for web server and CLI client. The project includes proper dependency management, environment configuration, and deployment-ready packaging.

Testing & Quality Assurance: Comprehensive error handling using Rust's Result types and custom error enums, ensuring robust error propagation throughout the application stack. The type-safe design prevents runtime errors and provides clear debugging information.

![GitDiagram](https://raw.githubusercontent.com/nihalxkumar/zingat/main/assets/zingatdiagram.png)

A web app to securely share texts on the internet with password protection and expiry date.

Zingat

- Lessons Notebook: https://github.com/nihalxkumar/lessons-notebook/
- OldTwitter: Zen Mode  https://github.com/dimdenGD/OldTwitter/discussions/1141
- API Dash: Workflow for Arch packaging and Docs for same https://github.com/foss42/apidash/pull/594
- FreeTube: Option to remove videos for playback queue https://github.com/FreeTubeApp/FreeTube/issues/6968
- Linux: Directly helped 5 people transition to linux. Indirectly many. https://www.kernel.org/category/about.html
https://invent.kde.org/websites/endof10-org/-/merge_requests/214

Some code and non code contributions to Open Source projects

Misc Contributions

Ever since I took my first breath, I’ve relied on communities. It’s the shared support of individuals; each contributing their part in a collaborative effort that allows us all to grow.

In recent years, I’ve taken an active role in several communities, some of which might look good on a portfolio website projects section :)

During my first semester, I noticed a critical gap: there was no central community for collaboration and peer support. I took the initiative to build one from the ground up. At its core is a thriving Discord server that now connects over 1,000+ students across different academic years and geographical locations. This ecosystem has expanded to include a GitHub organization for collaborative projects and a LinkedIn group for professional networking.

The true milestone isn’t the numbers but the culture. Together, we’ve created a supportive environment where students and professionals, from first-years to alumni, can connect, share knowledge, and learn from one another. Watching this community overcome isolation and grow into a self-sustaining network gives me immense joy.

Beyond this initiative, I’m also an active participant in several open-source and local tech communities, including FOSS United, KDE India, Ente, Free Software Community of India(FSCI), OpenStreetMap India, Prav, Delhi Technical Campus FOSS Club, Bennett University FOSS Club and some Linux and Privacy forums under disguised names.

because communities drive societal development.

Communities

Prav chat app is a messaging service that enables secure texts, calls, and file sharing using open-source XMPP technology, allowing users to communicate across different apps and services without vendor lock-in while prioritizing user privacy and cooperative governance

My contributions to the website: https://codeberg.org/prav/website/commits/branch/main/search?q=author%3Anihal&all=

Prav is a community owned XMPP chat app. I assist them as a web master.

Prav - Private Messenger

> What is MCP(Model Context Protocol)?
MCP is an open-source standard for connecting AI applications to external systems. Using MCP, AI applications like Claude or ChatGPT can connect to data sources (e.g. local files, databases), tools (e.g. search engines, calculators) and workflows (e.g. specialized prompts)—enabling them to access key information and perform tasks.
Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect electronic devices, MCP provides a standardized way to connect AI applications to external systems.

Arch MCP provides three main capabilities:

- Access to Arch Wiki, AUR packages, official repos, and installed packages
- Search, analyze, and securely install packages with built-in 50+ safety checks
- Guided workflows for troubleshooting, security audits, and dependency analysis

Complete Documentation for Arch-MCP https://nxk.mintlify.app/arch-mcp

![MCP_M-N_Connections](https://cdn.prod.website-files.com/67053868fc01e494462e71c9/67dad4f5bfd37c68494a0d13_MCP-m-n-connections.webp)


![Github OpenGraph](https://opengraph.githubassets.com/e68532bb91295f151409bc4e5591b55ec51a5fcacddc8849caa1c7b906622d13/nihalxkumar/arch-mcp)

An MCP Server to communicate with Arch wiki and packages

Arch Linux MCP

> What is Arch Linux? 
Arch Linux is a lightweight, rolling-release Linux distribution favored by developers for its minimalist design philosophy and cutting-edge software packages. Unlike distributions that bundle pre-compiled software, Arch provides users with powerful package management tools and expects them to build their system to their exact specifications.

The Arch User Repository (AUR) is a community-maintained repository containing over 85,000 user-contributed packages making it one of the largest software repositories in the Linux ecosystem. For comparison, Debian's official repositories contain roughly 60,000 packages. The AUR serves millions of Arch Linux users worldwide, providing access to software ranging from bleeding-edge development tools to specialized scientific applications. Arch Linux thrives on user contributions and experiences, encouraging collaboration and knowledge sharing. 

Each AUR package requires writing PKGBUILDs - specialized bash scripts that automate source fetching, dependency resolution, compilation, and installation. This demands deep understanding of build systems (Make, CMake, Meson), compilation flags, and cross-platform compatibility.

Maintaining packages requires git workflows, semantic versioning, tracking upstream changes, writing clear installation instructions, maintaining changelogs, testing packages across different system configurations, handling edge cases, and ensuring reproducible builds. This entire process develops the quality-focused mindset essential for shipping reliable software.

![Github OpenGraph](https://opengraph.githubassets.com/e68532bb91295f151409bc4e5591b55ec51a5fcacddc8849caa1c7b906622d13/nihalxkumar/PKGBUILDs)

I maintain and publish packages to the Arch User Repository (AUR)

Nihal Kumar

Projects