DEV Community: Khalid Danishyar

I got tired of fighting Jupyter notebook exports, so I built JupyTools

Khalid Danishyar — Sun, 10 May 2026 03:41:23 +0000

If you work with Jupyter notebooks long enough, you eventually hit the same annoying wall:
Your notebook works perfectly… but now someone wants it in another format.
A professor asks for a PDF.
A manager wants a Word document.
A teammate needs clean Markdown for GitHub.
Someone else just wants to open the notebook without installing Jupyter.
And suddenly you’re debugging nbconvert, installing Pandoc, fighting LaTeX errors, or trying to clean giant notebook outputs before pushing to Git.
I ran into this problem constantly while working between notebooks, documentation, and reports. Sometimes I was on a locked-down work machine. Sometimes I was helping students. Sometimes I just needed a quick export without rebuilding an entire Python environment.
That frustration became JupyTools.
What JupyTools does
👉 https://jupytools.com/
JupyTools is a browser-based toolkit for working with Jupyter notebooks.
No installs.
No account.
No server-side processing for core tools.
Everything runs directly in your browser session.
You can:
• Convert .ipynb to Word (.docx)
• Export notebooks to PDF
• Generate Markdown for GitHub
• Create HTML exports
• Convert notebooks to Python scripts
• Turn Python scripts back into notebooks
• Clean notebook outputs before sharing
• Merge multiple notebooks
• Split large notebooks into smaller sections
• Open and preview notebooks directly in the browser
The main goal was simple:
Make notebook workflows feel lightweight again.
The problem with notebook exports
Most notebook tools are built for people who already have a full local Python environment.
That sounds fine until you switch machines, work with students, collaborate across teams, or need to submit something quickly.
In practice, I kept seeing the same issues:
• nbconvert dependencies breaking
• Pandoc not installed
• PDF exports failing because of LaTeX
• Huge notebooks bloated with outputs
• Reviewers unable to open .ipynb
• Git diffs polluted by execution metadata
• People asking for Word files instead of notebooks
The worst part is that none of these problems are related to the actual analysis.
They’re just workflow friction.
So instead of adding another desktop dependency, I built a tool that works directly in the browser.
Why browser-based matters
One thing I learned from working with notebooks in different environments is that setup friction kills momentum.
Sometimes you only need a quick conversion.
Sometimes you’re borrowing a machine.
Sometimes IT policies block installs entirely.
Sometimes you’re helping a non-technical teammate who just needs a readable document.
With JupyTools, you open the site, drop the file, choose the export format, and download the result.
That’s it.
No environment setup.
No login wall.
No “install these six packages first.”

The features I personally use most

IPYNB → DOCX This became surprisingly useful. A lot of people still review work in Microsoft Word. Researchers, professors, managers, and clients often prefer editable documents over notebooks. The DOCX export keeps: • Headings • Markdown structure • Code blocks • Inline outputs • Images and plots

That means you can hand in a real Word document without manually copying notebook content into another editor.

Notebook Output Cleaner If you use Git with notebooks, you already know the pain. A tiny code change creates a massive diff because outputs, execution counts, or metadata changed. Before sharing notebooks publicly, I almost always clean them first. The cleaner removes noisy outputs while keeping the notebook structure intact. It’s especially useful before: • Git commits • Pull requests • Email attachments • Sharing notebooks with students • Uploading examples publicly
Notebook Viewer Sometimes people just want to read a notebook. Not run it. Not install Jupyter. Just open it. The viewer lets you inspect Markdown, code cells, and outputs directly in the browser. I originally built this because I kept sending notebooks to people who couldn’t open them properly.
Merge + Split notebooks This came from teaching workflows. I often had: • multiple labs that needed to become one notebook • giant notebooks that needed to be split into lessons Most notebook tools don’t handle this cleanly. Now I use merge/split constantly for tutorials and documentation prep. Privacy was a big requirement One thing I strongly wanted from the beginning: Your notebook should stay local whenever possible. A lot of notebooks contain: API keys • internal datasets • experiment outputs • customer information • unreleased research That’s why the core conversion flow runs client-side in the browser. Your files stay in the browser session until you download the result. I built it this way because I personally don’t like uploading notebooks to random conversion services either. Who this is for JupyTools is especially useful if you: • Work with Jupyter regularly • Teach data science or Python • Submit notebooks for grading • Share notebooks with non-technical teams • Need Word or PDF exports often • Use GitHub heavily • Review notebooks on different machines • Want quick conversions without local setup The workflow I use now My current notebook workflow looks something like this:
Build analysis in Jupyter or VS Code
Clean outputs before commit
Export Markdown for docs
Export PDF for sharing
Generate DOCX when stakeholders want edits
Bundle everything into ZIP when handing off work That entire process now takes a couple of minutes. Before building this, I used to spend way too much time fighting tooling instead of focusing on the actual work. Things I still want to improve I’m actively improving: • export formatting • large notebook handling • syntax highlighting • table rendering • mobile experience • notebook preview performance I also want to add more workflow-focused utilities instead of turning this into “just another converter site.” The goal is to support the real day-to-day notebook workflow developers and analysts already have. Final thoughts Jupyter notebooks became the standard for experimentation, teaching, and data science work. But the surrounding tooling still feels more complicated than it should. I built JupyTools because I wanted a faster, simpler way to move between notebooks, documents, scripts, and shareable formats without constantly rebuilding environments. If that sounds useful to you, I’d genuinely love feedback from the DEV community. 👉 https://jupytools.com/ Especially: • export issues • formatting bugs • missing formats • workflow pain points • notebook utilities you wish existed I’m building this primarily for developers, analysts, researchers, and students who live inside notebooks every day.

JPG to Excel: Stop Retyping Table Data From Images Like It's 2005

Khalid Danishyar — Tue, 17 Mar 2026 12:46:15 +0000

You know that specific kind of workplace suffering where the answer is right in front of you — literally visible on your screen — but completely out of reach?
That's the JPG to Excel problem.
Someone sends you a photo of a table. Or you've got a scanned report. Or you screenshot a pricing grid from a website that won't let you copy text. The data is right there. Every row, every column, every number — perfectly readable. And yet getting it into a spreadsheet means one thing: typing it all out by hand, one cell at a time, praying you don't make a mistake on row 17.
I've been in that chair. A lot of people have. And it's genuinely one of those friction points that nobody complains about loudly enough, because it feels too mundane to escalate — but quietly eats hours every single week.

Why Generic OCR Doesn't Cut It

The first thing most people try when they need to convert JPG to Excel is a standard OCR tool. Makes sense on paper. OCR reads text from images. You need text from an image. Problem solved, right?
Not quite.

Standard OCR tools read text the way a child reads a page before they understand sentences — left to right, top to bottom, no concept of what the structure means. So you get output that looks like this: a long block of text where your column headers and row values are all mashed together, and you spend the next twenty minutes figuring out which number belonged to which cell.
That's not a spreadsheet. That's a different problem wearing the same coat.
What you actually need when you want to convert from JPG to Excel isn't just text recognition — it's table structure recognition. The tool needs to understand that these values belong in these columns, those labels belong in those rows, and the whole thing needs to output as a properly structured XLSX file that opens cleanly in Excel or Google Sheets.
That distinction is everything.

The Tool That Actually Gets It Right

Asli Tools' JPG to Excel converter is built around exactly that distinction. It doesn't just extract text — it detects table structure and maps your data into the correct cells in a proper Excel file.
Here's the workflow:

Go to aslitools.com/tools/jpg-to-xlsx/
Drag your JPG in — or click to browse
Hit Convert to Excel
Download your XLSX file

That's genuinely it. No account. No installation. No credit card. You want to convert JPG to Excel free — this is it, no strings attached.
The output is a standard XLSX file that opens in Excel, Google Sheets, LibreOffice, or anywhere else you work with spreadsheets. Clean formatting. No watermarks. No catches.

Batch Conversion Changes Everything

The feature that took this from "useful" to "genuinely transformative" for my workflow is batch processing.
You can upload up to 50 images at once. Each image converts to its own XLSX file. Download them all in a single ZIP.
If you're dealing with a multi-page scanned report, a stack of photographed forms, or an archive of historical tables — this is the feature that makes the whole thing practical. What would otherwise be an afternoon of copy-typing becomes a few minutes of uploading and downloading.

Real Situations Where This Saves You
Let me get specific about where this JPG to Excel converter actually earns its keep:
Legacy document archives. Old printed reports, paper records, filed spreadsheets that were never digitized. Photograph them or scan them, run them through, get structured data out.
Client-submitted materials. Clients who send photos of their hand-drawn tables or printed price lists (this happens more than anyone admits). No more manual transcription.
Research and analysis. Tables embedded in academic PDFs, screenshots from locked websites, photos from conferences and whiteboards. JPG convert to Excel in seconds instead of minutes.
Scanned invoices and forms. Finance teams who receive physical documents and need the data in a workable format before end of day.
Screenshot workflows. Any time you capture a table from your screen — competitor pricing, data from an app that won't export, a table from a PowerPoint someone sent — you can convert it straight to Excel without touching a keyboard.

What About Excel to JPG?

Worth mentioning the reverse use case too: sometimes you need to go the other direction and convert Excel to JPG. Maybe you want to embed a table in a presentation, share a clean image on social media, or send a non-editable snapshot of data to a client.
If you need to convert Excel to JPG format — turn a spreadsheet into an image — Asli Tools covers that direction too. The Excel to JPG converter works on the same principles: simple upload, clean output, no installation required.
So whether your workflow runs from image to spreadsheet or spreadsheet to image, convert excel to jpg or jpg convert to excel, the same platform handles both directions. That kind of coverage matters when you're dealing with data in the real world, which rarely moves in just one direction.

Tips for Getting the Best Results
A few things that consistently improve output quality:
Use high-contrast, well-lit images. The clearer the table lines and text, the more accurate the cell detection. A flatbed scan or a crisp screenshot will always outperform a blurry phone photo.
Keep the table straight in the frame. Slight angles are usually fine. Significant rotation isn't. If you're photographing a printed document, get it as flat as possible.

Crop to just the table. Removing extra whitespace or surrounding content helps the tool focus on what matters.
One table per image when possible. Complex layouts with multiple tables on a single page sometimes do better when split into separate images.
Do a quick spot-check. Especially for merged cells or irregular headers, a thirty-second review against the original saves any downstream confusion.

The Honest Bottom Line

There's nothing revolutionary about wanting to convert JPG to Excel. It's a mundane problem. But mundane problems that waste hours every week deserve good solutions.
Asli Tools built one. It's free, it requires nothing from you except the image, and it handles the structural part that every other solution fumbles. Whether you need to convert from JPG to Excel for a one-off task or it's a recurring part of your workflow, it belongs in your toolkit.
Go try it: Jpg to Excel
Your spreadsheets will be ready before your coffee gets cold.

Using a different method for image-to-spreadsheet conversion? Share it in the comments — always looking for better approaches.

I Built AsliTools.com Using Modern Frontend Technologies — Now Serving 15K+ Monthly Users

Khalid Danishyar — Mon, 02 Mar 2026 07:40:15 +0000

Over the last few months, I’ve been building AsliTools.com — a privacy-first platform offering 250+ free online tools for file conversion, PDFs, images, calculators, and more.

What started as a small side project to solve my own frustrations has now grown to 15,000+ monthly users — entirely organic.

In this post, I want to share the developer side of the story:

Why I built it

The frontend architecture decisions

Performance and privacy challenges

And what scaling to 15K+ users taught me

The Initial Idea

As a developer, I constantly needed quick utilities:

Merge or split PDFs

Convert file formats

Compress images

Remove backgrounds

Generate QR codes

Every existing platform had one or more of these issues:

Forced signups

Aggressive paywalls

File size limits

Slow processing

Questionable privacy

I wanted to build something different:

Fast. Private. No login. No nonsense.

Tech Stack & Frontend Approach

This project was heavily frontend-driven by design.

The core principle:
Process as much as possible directly in the browser.

Why?

Better privacy

Reduced server costs

Faster perceived performance

Easier horizontal scaling

What I Used

Without going too deep into implementation details, the stack focuses on:

Modern React-based architecture

Optimized component structure for reusability

Client-side file processing APIs

Web Workers for heavy processing tasks

Efficient state management

Lazy loading & code splitting

SEO-optimized rendering strategy

Performance-focused asset delivery

A big challenge was keeping bundle size under control while supporting 110+ formats and 250+ tools.

Tree-shaking, dynamic imports, and aggressive optimization were essential.

Performance as a Core Feature

When building utility tools, speed is not optional — it is the product.

I focused on:

Minimal UI friction

3-step workflows (Upload → Select → Convert)

Fast first contentful paint

Smooth interactions even on slower devices

Lightweight UI with no unnecessary animations

Every extra second of delay increases drop-off.

With 15K+ monthly users now, performance consistency matters more than ever.

Privacy by Architecture

One of the most important decisions:

Files should never leave the user’s device whenever possible.

Most conversions and processing happen directly in the browser.

That means:

No file storage

No user accounts

No background tracking

No personal data handling

This significantly simplifies compliance, improves user trust, and reduces backend complexity.

Scaling to 15K+ Monthly Users

What surprised me most wasn’t the traffic growth.

It was how sensitive users are to friction.

Small UX changes impacted engagement more than adding new tools.

Some lessons from real usage data:

Clear tool categorization improves retention

Faster processing increases repeat visits

Simplicity outperforms feature overload

Trust signals matter

Organic traffic is now consistently above 15,000 users per month, and it’s growing steadily.

No paid ads so far.

Challenges

Building 250+ tools isn’t just about duplicating templates.

Each tool introduces:

Edge cases

Format inconsistencies

Browser compatibility issues

Performance tradeoffs

Supporting multiple file types at scale while keeping everything lightweight required careful architectural planning.

What’s Next

Now that the foundation is stable, I’m exploring:

Advanced batch processing

More developer-focused utilities

API access

Further performance improvements

Sustainable monetization without breaking the “free & private” promise

Why I’m Sharing This

Because building real utility products teaches you different lessons than building SaaS dashboards.

You learn about:

UX psychology

Performance engineering

Privacy-first architecture

Scalability without complexity

If you're a frontend developer thinking about building something practical and high-traffic — utility products are underrated.

If you want to check it out:
https://aslitools.com

I’d love feedback from fellow developers — especially around architecture, scaling, and frontend optimization strategies.

Transactional and Marketing Emails for AsanTyping.com

Khalid Danishyar — Tue, 02 Dec 2025 11:20:03 +0000

Over the past few weeks, I’ve been exploring different email service providers for transactional emails for AsanTyping.com. I tested MailerLite, Mailgun, Mailchimp, and even AWS SES.

What I found:

Most platforms are either too expensive, especially when it comes to marketing emails

AWS SES is definitely the cheapest for transactional emails, but once you add marketing features, the pricing climbs quickly

For my current needs, I needed something simple, reliable, and budget-friendly

So for now, I’ve decided to use Resend’s free plan for all transactional emails — and honestly, it’s been a great fit.

I’ve just finished integrating it, and now:
✅ Email verification
✅ Forgot password emails
✅ Welcome emails
…are all live and fully functional!

It feels good to check this off the list. If you’re building something early-stage and want a lightweight solution for transactional emails, Resend might be worth a look.

Best Next.js Portfolio for Full Stack Web Developers! (Live Demo Included)

Khalid Danishyar — Tue, 02 Dec 2025 10:40:15 +0000

Creating a standout portfolio is one of the most important steps for any Full Stack Web Developer in 2025. Whether you're applying for jobs, attracting freelance clients, or showcasing your technical expertise, your portfolio is your digital identity.

Today, I want to highlight one of the best developer portfolios built with Next.js, modern UI, fast performance, clean animations, and SEO-ready structure — a perfect inspiration for developers who want to build or improve their own portfolio site.

Live Demo: https://khaliddanishyar.com

Why a Next.js Portfolio Matters in 2025

Next.js continues to dominate the modern web ecosystem thanks to its:

Blazing fast performance

SEO optimization with Server-Side Rendering (SSR)

File-based routing

Image optimization

Seamless API integration

Support for modern UI frameworks like Tailwind CSS

If you're a Full Stack Web Developer, using Next.js for your portfolio is not only powerful — it's strategic.

A Perfect Example: Khalid Danishyar’s Full Stack Developer Portfolio

One of the most polished and professional examples of a Next.js portfolio is built by Khalid Danishyar, a Full Stack Web Developer with 7+ years of experience.

His portfolio demonstrates what a modern developer website should include:

Key Features That Make This Next.js Portfolio Stand Out

Clean & Professional Hero Section

The homepage immediately highlights:

Developer name

Specialization (Full Stack Web Developer)

Tech stack badges (Laravel, Next.js, React, Tailwind CSS, WordPress)

This instantly communicates skills to recruiters and clients.

Strong Personal Branding

The site uses:

A friendly greeting

A professional high-quality photo

A compelling summary of experience and education

These elements build trust and authenticity — crucial for conversions.

Metrics That Impress

Showcasing numbers like:

80+ Projects

60+ Clients

7+ Years of Experience

helps build instant credibility and sets expectations.

Clear Call-to-Action Buttons

The buttons are designed to drive engagement:

Contact Me

View Portfolio

Services

A strong CTA layout increases conversions significantly.

Fully Responsive & Fast

The portfolio is optimized for:

Desktop

Tablet

Mobile

Thanks to Next.js + Tailwind CSS, the performance remains smooth with minimal load time.

SEO Optimized Structure

The site is structured following SEO best practices:

Semantic HTML

Optimized metadata

Fast load speeds

Server-side rendering

Clean URL structure

This makes it more discoverable on Google search.

Modern UI + Clean Code = A Winning Combination

Using a tech stack like:

Next.js

React

Tailwind CSS

Laravel (backend projects)

WordPress (CMS projects)

this portfolio is both visually impressive and technically solid — exactly what clients and employers want.

Want to See the Live Demo?

Visit the Full Portfolio Website:
https://khaliddanishyar.com

Explore the layout, UI, project examples, and structure — and use it as inspiration for your own Next.js portfolio website.