DEV Community: Suryansh Soni

Know: A Developer Productivity Workspace Inside VS Code

Suryansh Soni — Fri, 14 Aug 2026 08:53:40 +0000

Most developers already have a code editor, a task manager, a timer, a project tracker, and GitHub open somewhere.

Know is an attempt to bring the essential parts of that workflow directly into VS Code.

It is a free developer productivity workspace designed around the development environment itself.

What is Know?

Know helps developers organize, focus on, and track their development work without constantly switching between applications.

The core workflow is:

Create Task
↓
Organize Project
↓
Start Focus Session
↓
Code
↓
Review Progress
Key Features
🎯 Focus Sessions

Create focused coding sessions directly inside VS Code.

You can:

Start predefined or custom-duration sessions
Pause and resume sessions
Extend an active session
Track completed focus time
Continue working without leaving your editor
✅ Task Management

Keep development tasks close to the code they belong to.

Know supports:

Inbox tasks
Priorities
Categories
File-linked tasks
Today's tasks
Task history

You can also create tasks directly from the current file.

📁 Project Management

Organize work around actual development projects.

Projects can be associated with your current VS Code workspace and repository, making it easier to keep project context together.

🐙 GitHub Integration

Know provides GitHub repository workflows directly from VS Code.

You can import repositories, associate existing workspaces, and work with repository information without leaving the editor.

📊 Productivity Statistics

Know provides a view of your development activity over time, including:

Focus time
Activity history
Streaks
Project breakdown
Category breakdown
Activity heatmaps

The goal isn't to turn development into a competition. It's to give you a clearer picture of how you spend your development time.

🔒 Local-First

Know is designed around local development.

Your tasks, projects, focus sessions, and productivity data are stored locally.

There is no requirement to create an account just to use the core functionality.

Why Build This?

I wanted a developer-focused workspace that didn't require constantly moving between:

VS Code
Task managers
Timers
Project trackers
Notes
Productivity dashboards

Instead, the idea is to keep these workflows close to the code.

Know is still evolving, and the project is being developed with real developer workflows in mind.

Documentation

The project documentation is separated into dedicated sections rather than putting the entire technical specification into the Marketplace README.

This keeps the main project page focused while making deeper documentation available for developers who want to understand how Know works.

Try Know

VS Code Marketplace:
Know — Visual Studio Marketplace

GitHub:
Know — GitHub Repository

If you use Know, feedback on the workflow, UX, bugs, and feature ideas is welcome.

Built for developers who want to spend more time coding and less time managing their tools.

🚀 SuriLens: An Open-Source Real-Time Backend Execution Visualizer for Node.js

Suryansh Soni — Sat, 01 Aug 2026 19:32:39 +0000

Backend debugging often relies on scattered console.log() statements, browser network tabs, and server logs. As applications grow, understanding how a request moves through middleware, controllers, services, databases, and external APIs becomes increasingly difficult.

To solve this problem, I built SuriLens—an open-source real-time backend execution visualizer and observability toolkit for Node.js.

It helps developers understand exactly what happens inside their backend while requests are being processed.

✨ Why I Built SuriLens

While building production-grade Node.js applications, I often found myself asking questions like:

Which middleware executed first?
Where is this request spending most of its time?
Which controller handled the request?
Which database query was executed?
Which external APIs were called?
Which payload changed between different stages?
Why is this request slow?

Finding these answers usually meant adding temporary logs, restarting the server, and repeating the same process.

I wanted a tool that could visualize everything automatically.

That's how SuriLens was created.

🔍 What is SuriLens?

SuriLens is a lightweight runtime observability package that automatically instruments your Node.js application and displays the complete execution flow inside an interactive dashboard.

Instead of reading logs, you can literally watch requests travel through your backend.

🚀 Features
⚡ Real-time request visualization
📊 Live execution graph
🔄 Automatic request tracing
🧩 Dynamic node generation
📦 Payload inspection
🔍 Payload diff viewer
🎬 Execution replay
📈 Timeline visualization
📡 WebSocket-powered live updates
🔌 Express support
🔌 Fastify support
🔌 Koa support
🔌 NestJS support
🔌 Hono support
🧠 Plugin SDK
🔐 Sensitive data masking
📤 Session export/import
📊 Performance metrics
🚨 Slow request detection
🚨 Slow step detection
🚀 W3C Distributed Tracing support
📸 How It Works

Every incoming request is automatically traced.

Instead of manually adding logs:

Client
│
▼
Express
│
▼
Middleware
│
▼
Controller
│
▼
Service
│
▼
Database
│
▼
External API
│
▼
Response

SuriLens visualizes this flow in real time with animated execution packets, timing information, payload transformations, and performance metrics.

💻 Installation
npm install surilens
🚀 Quick Start
import express from "express";
import suriLens from "surilens";

const app = express();

app.use(suriLens());

app.get("/", (req, res) => {
res.json({
message: "Hello World"
});
});

app.listen(3000);

Open:

http://localhost:4444

and start watching your backend execute in real time.

🖥 Dashboard Includes
Live execution graph
Timeline
Payload inspector
Request details
Response details
Performance metrics
Search
Filters
Replay engine
Dynamic execution nodes
🛠 Supported Frameworks
Express
Fastify
NestJS
Koa
Hono
🔒 Security

SuriLens automatically masks sensitive information such as:

Passwords
Authorization headers
Tokens
Cookies
API keys
Secrets

before broadcasting trace data.

⚡ Performance

Designed to be lightweight for development and observability.

Highlights include:

AsyncLocalStorage-based tracing
Automatic instrumentation
WebSocket streaming
Minimal runtime overhead
Dynamic execution graph
Live packet animations
🌍 Open Source

SuriLens is completely open source.

Contributions, issues, feature requests, and feedback are always welcome.

🔗 Links

GitHub

https://github.com/sonisuryansh/surilens

npm

https://www.npmjs.com/package/surilens

💙 Feedback Welcome

This is the first public release of SuriLens, and I'd love feedback from the developer community.

If you try it in your project, let me know:

What you liked
What could be improved
Which framework you'd like supported next
Features you'd like to see in future releases

Happy coding! 🚀

Building My Developer Portfolio: More Than Just a Personal Website

Suryansh Soni — Fri, 31 Jul 2026 04:19:46 +0000

A portfolio is often the first impression a recruiter, hiring manager, or fellow developer gets. Instead of treating it as a static resume, I wanted to build a website that reflects how I approach software engineering—clean design, responsive user experience, and modern web development practices.

That motivation led me to redesign and rebuild my portfolio from the ground up.

The Goal

I wanted a portfolio that could:

Present my projects in a structured way
Showcase my technical skills and experience
Make it easy for recruiters to contact me
Provide a smooth experience across all devices
Be fast, responsive, and easy to maintain

Rather than adding unnecessary animations or visual clutter, I focused on simplicity, performance, and usability.

What the Portfolio Includes

The website brings together everything about my professional journey in one place.

Visitors can:

Learn about me and my background
Explore my featured projects
View my technical skills
Read about my experience and achievements
Download my resume
Contact me directly
Access links to GitHub, LinkedIn, and other professional profiles

The goal was to make important information accessible within a few clicks.

Key Features

Modern responsive UI
Dark and light theme support
Smooth animations and transitions
Optimized loading performance
Mobile-friendly layout
SEO-friendly pages
Resume download
Contact section
Project showcase with live demos
Clean and scalable component structure

Tech Stack

Frontend

React
Tailwind CSS
JavaScript

Deployment

Vercel

Development Focus

While building the portfolio, I paid close attention to areas that directly impact user experience.

Some of the priorities included:

Responsive layouts for different screen sizes
Fast page load times
Reusable React components
Clean project organization
Accessibility considerations
Consistent typography and spacing
Smooth navigation between sections

The objective wasn't to build the most complex portfolio—it was to build one that feels professional and communicates information effectively.

Challenges

Some of the challenges I encountered included:

Creating a layout that remains consistent across devices
Balancing animations without affecting performance
Organizing project content in a clean way
Optimizing assets for faster loading
Maintaining a scalable component structure as the portfolio grows

These challenges reinforced the importance of thoughtful UI/UX design and frontend optimization.

What I Learned

Building this portfolio helped me improve my understanding of:

React component architecture
Responsive web design
Performance optimization
UI consistency
Deployment workflows
Building maintainable frontend applications

It also reminded me that a portfolio should communicate not only what you've built but also how you think as a developer.

Future Improvements

I'm continuously improving the portfolio and plan to add:

Technical blog section
Project case studies
Interactive project demos
Search and filtering for projects
More accessibility enhancements
Analytics dashboard to understand visitor engagement

Final Thoughts

A portfolio is never truly finished—it evolves alongside your skills and experience.

This project has become a place where I can document my journey, showcase the products I've built, and reflect the standards I aim for as a software engineer.

I'm always open to feedback and ideas that can help make it even better.

Live Website: https://sonisuryansh.tech

GitHub: https://github.com/sonisuryansh/Portfolio

Building EpicMint: A Full-Stack NFT Marketplace with AI and Web3

Suryansh Soni — Fri, 31 Jul 2026 04:18:15 +0000

Web3 applications are often complex for new users. Creating wallets, minting NFTs, managing metadata, and interacting with smart contracts can quickly become overwhelming.

I wanted to explore how modern web technologies and AI could make the NFT creation experience more intuitive. That led to building EpicMint—a full-stack NFT marketplace that combines Web3, AI, and a modern MERN architecture.

The Idea

Most NFT platforms focus solely on blockchain interactions, leaving users to manually create titles, descriptions, upload metadata, and manage wallets.

EpicMint aims to simplify that workflow by integrating AI-assisted content generation alongside the traditional NFT minting process.

The objective was to build a platform that feels familiar to web users while leveraging blockchain where it adds value.

What EpicMint Does

EpicMint allows users to:

Create and mint NFTs
Connect their MetaMask wallet
Generate NFT titles and descriptions using AI
Upload NFT assets securely through IPFS
Browse and explore minted NFTs
Manage their NFT collection through a personalized dashboard

The result is a platform that combines the accessibility of modern web applications with decentralized ownership.

Key Features
NFT minting with smart contracts
MetaMask wallet integration
AI-generated NFT titles and descriptions
IPFS-based metadata and asset storage
Secure authentication
User profile and NFT management
Responsive interface for desktop and mobile
Modern dashboard experience
Tech Stack
Frontend
React
Tailwind CSS
JavaScript
Backend
Node.js
Express.js
Database
MongoDB
Blockchain
Solidity
Ethereum
MetaMask
Ethers.js
Decentralized Storage
IPFS
Pinata
AI
Google Gemini API
Deployment
Vercel
Render
Architecture Overview
React Frontend
│
▼
Express REST API
│
┌──────┴────────┐
│ │
▼ ▼
MongoDB Gemini AI
│
▼
User Data

MetaMask
│
▼
Ethereum Smart Contract
│
▼
IPFS (Pinata)

This architecture separates traditional application data from blockchain assets while keeping the minting workflow efficient and maintainable.

Challenges I Faced

Building EpicMint involved solving problems across multiple technologies.

Some of the biggest challenges included:

Integrating blockchain interactions with a traditional MERN application
Managing wallet connections and transaction states
Uploading NFT assets and metadata to IPFS
Synchronizing blockchain data with MongoDB
Designing an authentication flow alongside wallet connectivity
Deploying both frontend and backend services while managing environment variables

Each challenge required understanding not only how individual technologies work but also how they communicate with one another.

What I Learned

EpicMint helped me gain practical experience in:

Smart contract development
Web3 application architecture
Ethereum transactions
Wallet authentication
IPFS storage
AI integration in production applications
Secure backend API design
Deployment and environment management

More importantly, it taught me how to combine centralized and decentralized systems into a single user experience.

Future Improvements

The roadmap for EpicMint includes:

NFT marketplace buying and selling
Collection verification
Creator analytics dashboard
Royalty management
Multi-chain support
NFT search and filtering
Social features for creators
Improved gas optimization
Final Thoughts

EpicMint has been one of my most technically challenging projects because it combines multiple domains—full-stack development, blockchain, decentralized storage, and AI.

Building it strengthened my understanding of modern software architecture and demonstrated how Web2 and Web3 technologies can work together to create a better user experience.

This project continues to evolve, and I'm excited to keep improving it while learning more about scalable Web3 development.

Live Demo: https://epic-mint-major.vercel.app

GitHub: https://github.com/sonisuryansh/EpicMint-V2

Building GovChain: Making Government Scheme Discovery Simpler with AI

Suryansh Soni — Fri, 31 Jul 2026 04:16:46 +0000

Finding the right government scheme shouldn't require navigating dozens of websites or reading through lengthy eligibility documents. Yet for many students, professionals, farmers, and citizens, discovering relevant schemes is still a time-consuming and confusing process.

To address this problem, I built GovChain, an AI-powered platform that helps users discover government schemes based on their profile and eligibility.

The Problem

Government schemes are available for different categories of people, but users often struggle with:

Finding schemes relevant to their situation
Understanding eligibility criteria
Searching across multiple government portals
Reading complex documentation before knowing whether a scheme applies to them

The goal of GovChain is to simplify this entire process into an intelligent and user-friendly experience.

Solution

GovChain provides personalized scheme recommendations based on user information such as:

Student status
Occupation
Income range
Category and eligibility
Other relevant profile details

Instead of manually searching through hundreds of schemes, users receive recommendations tailored to their needs.

The platform also includes an AI assistant that answers questions about government schemes in natural language, making information more accessible.

Key Features

AI-powered government scheme recommendations
Personalized eligibility-based suggestions
Intelligent chatbot for scheme-related queries
Fast search and filtering
Responsive dashboard with a clean user experience
Secure authentication
Modern and scalable architecture

Tech Stack

Frontend

React
Tailwind CSS
JavaScript

Backend

Node.js
Express.js

Database

MongoDB

Google Gemini API

Deployment

Vercel
Render

Development Challenges

Every project comes with its own learning experience. Some of the challenges I worked through included:

Designing recommendation logic for different user profiles
Integrating AI responses into the application workflow
Managing secure authentication and API communication
Optimizing backend performance for faster responses
Deploying frontend and backend as separate services

Each challenge helped me better understand full-stack application architecture and production deployment.

What I Learned

Building GovChain strengthened my understanding of:

Full-stack application development
REST API design
AI integration using LLM APIs
Authentication and backend security
Deployment workflows
Building user-centric products instead of feature-centric applications

Future Improvements

Some ideas I plan to explore in future versions include:

Multi-language support
Smarter recommendation algorithms
Real-time scheme updates
User feedback system
Bookmark and application tracking
Admin dashboard for scheme management

Final Thoughts

GovChain started as an idea to simplify access to government schemes, but it became an opportunity to learn how AI can improve real-world user experiences.

Building products that solve practical problems is one of the best ways to grow as a software engineer, and this project taught me valuable lessons in system design, backend development, AI integration, and deployment.

I'd love to hear your thoughts or suggestions for improving the platform. Feedback is always welcome!

Live Demo: https://govchainsh.vercel.app/dashboard

GitHub: (Add your repository link here if it's public.)