DEV Community: Aryan Tailor

Understanding PDF Extraction: From Raw Text to Structured JSON

Aryan Tailor — Mon, 21 Sep 2026 14:22:03 +0000

Understanding PDF Extraction: From Raw Text to Structured JSON

PDFs look simple to us.

We open a document, see tables, headings, values, and paragraphs, and immediately understand how everything is organized.

A computer doesn't see it that way.

For a program, a PDF can be a collection of text fragments, coordinates, fonts, lines, images, and other objects. Extracting useful information from it is therefore much more complicated than simply reading the text.

In this article, I'll explain the process of going from a raw PDF to structured JSON, the problems that appear along the way, and some of the techniques that can make document extraction more reliable.

Why PDF extraction is difficult

A common assumption is:

PDF → extract text → convert to JSON

In practice, it is closer to:

PDF
 ↓
Extract text and layout information
 ↓
Understand positions and relationships
 ↓
Identify sections and fields
 ↓
Handle tables and columns
 ↓
Normalize values
 ↓
Validate the extracted data
 ↓
Structured JSON

The main problem is that a PDF is primarily designed to display information, not necessarily to represent that information semantically.

For example, a document might visually contain:

Invoice Number        INV-1024
Date                  12/08/2026
Total Amount          ₹45,000

But the PDF might internally store these as separate text objects positioned at different coordinates.

The program has to figure out that:

"Invoice Number" → "INV-1024"
"Date"            → "12/08/2026"
"Total Amount"    → "₹45,000"

1. Starting with raw text extraction

The first step is usually extracting text from the PDF.

Python has several useful libraries for this. One example is PyMuPDF, which provides access to both text and layout-related information.

A basic extraction can look like:

import fitz

doc = fitz.open("document.pdf")

for page in doc:
    text = page.get_text()
    print(text)

This works surprisingly well for simple PDFs.

However, the result can become difficult to use when the document contains:

multiple columns
tables
merged cells
headers and footers
irregular spacing
text positioned manually
multi-page sections

For example, instead of getting:

Name: John
Age: 21
Country: India

you might get text in an order that doesn't perfectly match the visual layout.

That's where layout information becomes important.

2. Coordinates are extremely useful

Instead of extracting only the text, we can extract information about where the text appears on the page.

Conceptually, each piece of text can be represented as:

Text + Position + Size

For example:

"Invoice Number" → x=80, y=120
"INV-1024"       → x=250, y=120

Now we can reason about their relationship.

If two pieces of text have similar Y coordinates, they are probably on the same row.

If one appears to the right of another, it may be its corresponding value.

This allows us to reconstruct parts of the document's visual structure.

3. Thinking in rows and columns

Suppose a PDF contains:

Item       Quantity       Price
Laptop     2              80000
Mouse      3              1500

A text extractor might return individual text elements.

Instead of immediately converting them into JSON, we can first group them based on their coordinates.

A simplified representation might look like:

Row 1:
Item | Quantity | Price

Row 2:
Laptop | 2 | 80000

Row 3:
Mouse | 3 | 1500

Then the table can be converted into something structured:

[
  {
    "item": "Laptop",
    "quantity": 2,
    "price": 80000
  },
  {
    "item": "Mouse",
    "quantity": 3,
    "price": 1500
  }
]

The important idea here is that layout reconstruction happens before data structuring.

4. Detecting sections

Large documents usually aren't one giant table.

They contain different logical sections.

For example:

Document Details
Status
Declarant
Manifest Details
Container Details
Invoice Summary
Valuation
Duties

A useful extraction pipeline therefore needs to identify where one section ends and another begins.

Instead of treating the document as one large block of text, we can represent it internally as:

Document
 ├── Document Details
 ├── Status
 ├── Declarant
 ├── Manifest Details
 ├── Container Details
 ├── Invoice Summary
 └── Valuation

Once these sections are identified, each one can be processed independently.

This makes the final JSON much easier to work with.

5. Designing the JSON schema

Before writing the extraction logic, it helps to define what the final output should look like.

For example:

{
  "doc_details": {},
  "status": {},
  "declarant": {},
  "manifest_details": {},
  "container_details": {},
  "invoice_summary": {},
  "valuation_and_duties": {}
}

The schema acts as a contract.

Instead of asking:

"What information can I find in this PDF?"

we can ask:

"Where should each piece of information go in my predefined structure?"

That distinction is important when building reliable document-processing systems.

6. Missing values should remain predictable

Real-world documents aren't always complete.

A particular field might not exist in a document.

Instead of changing

Stop Following AI Tutorials: Build Projects Instead

Aryan Tailor — Thu, 30 Jul 2026 10:46:51 +0000

Stop Following AI Tutorials: Build Projects Instead

You just finished a 10-hour course on building AI apps. You typed along, ran the code, and watched the demo light up. You feel like a genius.

Then you open a blank IDE to build something of your own... and you freeze.

Welcome to Tutorial Hell. It is the most comfortable trap in software development, and right now, it’s keeping thousands of aspiring AI engineers stuck in place.

The Illusion of Progress

Tutorials are designed to succeed. They hand you clean datasets, pre-configured API keys, and error-free code snippets.

In the real world, production AI looks like this:

APIs rate-limit your requests mid-stream.
Vector databases return junk context because your chunking strategy was flawed.
Models ignore system prompts and output malformed JSON.
Latency makes your UI completely unusable.

When you follow a step-by-step video, you aren't learning engineering—you're practicing typing. Real skill starts where the tutorial ends: in the messiness of unhandled edge cases and unpredictable systems.

How to Learn AI Through Projects

The secret isn't finding a "better course." It's embracing friction-driven learning. You need to build something where failure forces you to read raw documentation and debug network calls.

The "Fork & Break" Framework

If a blank screen feels overwhelming, don't start from scratch. Take an existing open-source project and force it to do something it wasn't built for:

Clone an existing repo (e.g., a standard RAG pipeline).
Break one core assumption: Swap the vector store, introduce multi-modal inputs, or replace cloud APIs with a local open-source model.
Fix what broke. Resolving those exact errors will teach you more about token limits, context windows, and embeddings than 50 hours of passive watching.

What Companies Actually Want in 2026

Hiring managers aren't impressed by another generic "Chat with your PDF" app using a wrapper framework. Hundreds of candidates have that on their GitHub.

Here is what sets high-value candidates apart:

What Novices Showcase	What Production AI Teams Look For
Simple API calls	Latency & Cost Engineering (Semantic caching, model routing, smaller open models)
"It works on my local machine"	Evaluation Pipelines (Benchmarking model accuracy and drift at scale)
Basic prompt strings	Resilience & Guardrails (Schema enforcement, retry logic, fallback handlers)
Toy notebooks	Deployment Systems (Async processing, Dockerization, observability, and logging)

Companies don't hire people who know how to plug in an API key. They hire engineers who know how to manage cost, latency, and system failures.

A 4-Step Action Roadmap

If you want to transition from passive learner to capable AI engineer, structure your next month like this:

Step 1: Build a Minimal Baseline

Pick a narrow, non-generic problem (e.g., "Summarize pull requests for my team"). Write the rawest script possible using a standard API to get a working baseline.

Step 2: Introduce Real Constraints

Add production constraints: Set a strict response budget under 2 seconds, enforce 100% structured JSON outputs, and implement caching to cut API costs in half.

Step 3: Build an Evaluation Framework

Write tests for your system. How do you know a prompt tweak actually improved output quality? Measure accuracy, hallucination rates, and edge-case failures across 50 test inputs.

Step 4: Deploy & Monitor

Package your system as a service. Wire up telemetry to track token consumption, latency distribution, and production error logs.

Bottom Line

Stop watching other people build things. Close the course tab, open your terminal, pick a small problem that annoys you, and start breaking stuff.

The struggle isn't a roadblock—it's the learning.

Is the Junior Developer Pipeline Broken? How AI Changed the Career Ladder

Aryan Tailor — Wed, 29 Jul 2026 10:10:49 +0000

For over two decades, the software engineering career path followed a predictable, unspoken deal:

Junior Developers wrote boilerplate, fixed minor bugs, wrote unit tests, and handled tedious refactoring.
Seniors mentored them, reviewed their PRs, and handled system architecture.
Over 2–3 years, juniors absorbed enough contextual knowledge to climb the ladder to mid-level.

That pipeline was the industry’s primary talent engine. But over the last few years, AI coding assistants changed the underlying math.

When AI can draft utility functions, write test suites, and scaffold API routes in seconds, the traditional "grunt work" that trained new engineers is vanishing.

So, is the entry-level pipeline broken—or is it just evolving into something entirely different?

📉 The Shifting Ground: What the Data Shows

Over 84% of developers now incorporate AI tools into their daily workflows. While overall tech employment remains resilient, the entry-level entry barrier has spiked dramatically:

The Compression of Grunt Work: Tasks traditionally assigned to interns and juniors (writing basic regex, generating unit tests, setting up standard boilerplate) are now completed in seconds using LLM workflows.
The Escalating Seniority Floor: Postings for "entry-level" roles increasingly ask for candidates who demonstrate architectural understanding and system design on day one.
The Mentorship Gap: Seniors, equipped with AI, can handle 3x–5x more output independently, reducing the immediate financial incentive for teams to hire and train raw beginners.

🔄 Old Junior Role vs. New Junior Role

The expectations for what makes a candidate "job-ready" have shifted from raw code syntax to critical evaluation.

Paradigm	Traditional Junior Developer	Modern (AI-Era) Junior Developer
Primary Task	Writing lines of code & boilerplate	System integration, validation, & code auditing
Daily Output	~100–300 lines of manual syntax	Orchestrating AI generation & refining edge cases
Key Skill	Syntax fluency & memorization	System design, data modeling, & debugging complex interactions
Bottleneck	Speed of typing & searching docs	Critical thinking, security awareness, & business context

🛠️ How Early-Career Developers Can Adapt

If you are breaking into the industry today, competing on how fast you can write standard CRUD operations is a losing game. The key is positioning yourself as an orchestrator and auditor rather than just a code typist.

1. Build Deep Skepticism & Debugging Muscle

AI output is fast, but it frequently hallucinates edge cases, security vulnerabilities, or inefficient SQL queries. Developers who can quickly audit AI-generated code, spot structural flaws, and fix memory leaks are infinitely more valuable than those who blindly copy-paste solutions.

2. Focus on Fundamentals AI Struggles With

LLMs excel at isolated functions, but they often struggle with:

System Architecture & Data Modeling: Designing schemas that scale efficiently over time.
Cloud Infrastructure & DevOps: Container orchestration, CI/CD pipelines, and cloud setup (AWS/GCP/Azure).
Business Context & Product Trade-offs: Knowing what to build and why, rather than just how.

Key Takeaway: The goal isn't to avoid AI tools—it's to use them to operate at the level of a mid-tier engineer much earlier in your career.

💬 What's Your Take?

For the engineering managers, seniors, and juniors in the community:

Seniors & Leads: Is your team hiring fewer juniors, or have you adapted your onboarding process to teach AI-assisted engineering?
Juniors: What has your job hunt looked like over the past year?

Drop your thoughts and experiences in the comments below! 👇

A Beginner's Guide to Python: Your First Steps into the World's Most Popular Language

Aryan Tailor — Wed, 29 Jul 2026 09:59:23 +0000

Introduction
So, you’ve decided to learn how to code. Congratulations! You have taken the first step into a massive, creative, and rewarding world.

But with so many programming languages available—JavaScript, Java, C++, Ruby—where do you start? For many developers, the answer is simple: Python.

Python is famous for its simple, readable syntax, making it the perfect language for absolute beginners. It allows you to focus on learning coding logic without getting stuck on complex punctuation. But don't let its simplicity fool you; Python powers some of the world's most sophisticated technology, from Google Search and Netflix's recommendation engines to advanced NASA data analysis.

In this beginner's guide, we will break down exactly why Python is special and cover the foundational concepts you need to write your very first script. Let’s dive in!

Why Should You Choose Python? There are many reasons why Python is the "go-to" language for beginning programmers:

Readable and Simple: Python reads like English. It uses indentation to define structure, minimizing confusing symbols like curly braces {} and semicolons ;.

Massive and Active Community: Because so many people use Python, there are endless free resources, tutorials, and forums (like DEV.to!) where you can get help.

Incredible Versatility: Python is not specialized. You can use it for:

Web Development (using frameworks like Django or Flask).

Data Science and AI.

Automation and Scripting (making the computer do your boring tasks).

Game Development.

Setting Up Your Environment Before you can write Python, you need a place to run it. There are two main approaches for beginners:

The Easy Way: Online Editors
If you just want to write your first few lines without installing anything, use an online interactive environment (IDE).

Repl.it: A fantastic browser-based IDE that requires zero setup.

The Standard Way: Local Installation
This is how professional developers work.

Download Python: Go to the official Python website and download the latest version for your operating system (make sure to check the box "Add Python to PATH" during installation on Windows!).

Choose an Editor: You can write Python in a simple text editor (like Notepad), but a dedicated Integrated Development Environment (IDE) helps with syntax highlighting and errors. Beginners often love VS Code (free, powerful) or Thonny (designed specifically for learning Python).

Python Fundamentals: Your First Building Blocks With your editor ready, let’s explore the basic pieces of the Python language.

A. The print() Function
We must start with the tradition. The print() function is how you display information to the terminal or screen. It is your primary way of communicating with the user or debugging your code.

Python
print("Hello, DEV community!")
print(42) # You can print text or numbers
B. Variables and Data Types
A variable is simply a container used to store data in the computer's memory. In Python, you create a variable by simply giving it a name and assigning it a value using the = sign. Python automatically figures out what kind of data you are storing.

Python
username = "Ada" # This is a String (text)
age = 25 # This is an Integer (whole number)
height = 1.68 # This is a Float (decimal number)
is_online = True # This is a Boolean (True/False value)
You can change (mutate) these variables later if you need to:

Python
score = 0
score = score + 10
print(score) # This will output 10

How to Handle Data: Lists and Dictionaries Often, you won’t be dealing with just single items; you will deal with collections of data.

Lists
A List is an ordered collection of items, enclosed in square brackets []. It's like a shopping list or a checklist. Lists are ordered, meaning the computer remembers the sequence.

Python

A list of fruit strings

fruits = ["apple", "banana", "cherry", "kiwi"]

You access items in a list by their position (index), starting at 0!

print(fruits[0]) # Output: apple
print(fruits[1]) # Output: banana

You can easily change items or check how long the list is

fruits[3] = "strawberry" # Kiwi is replaced
print(len(fruits)) # len() gets the length, output: 4
Dictionaries
A Dictionary is an unordered collection of key-value pairs, enclosed in curly braces {}. Think of a physical dictionary: you look up a word (the key) to find its definition (the value).

Python

Keys must be unique!

user_profile = {
"username": "Ada",
"level": 12,
"is_premium": False
}

You access values by using their key:

print(user_profile["username"]) # Output: Ada
Conclusion
We have covered why Python is popular, how to set up your environment, and the four foundational data structures (Strings, Integers/Floats, Lists, and Dictionaries).

While this may feel complex, these concepts are simply the grammar and vocabulary of a new language. You have learned enough to start writing simple scripts, storing information, and printing instructions.

The secret to learning Python (and coding in general) is practice. Your next step is to build something tiny. Try creating a short script that calculates the area of a rectangle or stores a list of your favorite movies.