DEV Community: Deepak Patidar

I Tried Building a Better Job Search Workflow — Here’s What I Learned

Deepak Patidar — Tue, 11 Aug 2026 13:32:47 +0000

I've been thinking about a problem that sounds simple:

Why does applying for a job still require so much repetitive work?

We already have:

LinkedIn
Indeed
Resume builders
AI resume tools
Autofill tools
ATS platforms
Application trackers

Yet the workflow still looks something like this:

Find a job.

Read the description.

Change the resume.

Fill out another application.

Enter the same information again.

Go through a different ATS.

Submit.

Track the application.

Then repeat everything for the next job.

The problem isn't one bad tool

Most of these tools actually do their individual jobs reasonably well.

The problem is what happens between them.

Your job search becomes a collection of disconnected steps.

The candidate ends up doing all the "glue work":

moving information between systems
maintaining resume versions
repeating application details
remembering where they applied
tracking application status

That's the part I wanted to attack.

So I started building something

I'm building AAOS around a simple idea:

The job seeker shouldn't have to manually coordinate the entire workflow.

The system is designed to bring the repetitive parts together:

Discover → Match → Tailor → Apply → Track

The goal isn't simply to submit more applications.

It's to reduce the repetitive work around a serious job search while keeping the candidate in control.

For example, instead of manually opening a job, figuring out what needs to change in the resume, and then repeating information through another application flow, the system can handle much more of that workflow.

What surprised me

The hardest part isn't generating a resume.

AI can already do that.

The harder problem is building a reliable workflow that survives the messy reality of actual applications:

Different job platforms.

Different ATS systems.

Different questions.

Different resume requirements.

Different application states.

That's where I think there's still a lot of interesting engineering work to do.

I'm building AAOS to explore that problem.

I'm currently testing the workflow with real job seekers and looking at where it actually saves time versus where automation still falls short.

If you're interested in the engineering/product side of AI automation, I'd be happy to share more about how I'm approaching it.

You can also see the product here:

https://www.aaos.work

Title Why Is Finding a Job Still So Manual in 2026?

Deepak Patidar — Sun, 02 Aug 2026 18:33:17 +0000

Developers automate deployments.

Infrastructure.

Testing.

Monitoring.

CI/CD.

Almost everything.

Yet when it comes to finding a job...

Most people still:

Search manually
Rewrite resumes
Fill out forms
Track applications in spreadsheets
Wait for replies that often never come

We've automated software.

But not the journey to meaningful work.

That's one of the problems we're exploring with Omecra.

Mission #1:

Get Me Hired.

🌐 https://www.aaos.work

I'd love to hear:

What's the most repetitive part of your job search?

Why AI Agents Need More Than a Prompt-and-Response Loop

Deepak Patidar — Mon, 20 Jul 2026 11:19:57 +0000

AI agents are becoming more capable every month.

They can reason, use tools, call APIs, browse information, and generate surprisingly useful outputs.

But there is still a gap between an AI that can perform a task and a system that can reliably work toward a real-world goal.

Most AI interactions still follow a familiar pattern:

Prompt → Response → Stop

Real-world goals don't work that way.

They unfold over time.

The environment changes. Actions fail. APIs go down. Processes restart. New information appears. And sometimes an action that looked successful never actually produced the intended result.

For an AI system to work toward a persistent mission, it needs more than intelligence.

It needs an execution lifecycle.

From Tasks to Persistent Missions

Imagine giving an AI system a goal instead of a single instruction.

For example:

Find relevant job opportunities that match my preferences and help me pursue them.

Completing that mission isn't one model call.

The system may need to:

Observe the current state.
Decide what should happen next.
Take an action.
Verify whether the action actually worked.
Record the resulting state.
Recover when something fails.
Continue working toward the mission.

Then repeat.

Observe → Decide → Act → Verify → Commit State → Recover → Continue

The important part is continuity.

A model can provide intelligence at different points in this loop, but the mission itself needs to survive beyond any individual model call.

Why Verification Matters

Consider an AI agent that submits an application through an external system.

The agent clicks "Submit."

Did the application actually go through?

Maybe.

A button click is not the same as a verified outcome.

The page could have returned an error.

The session could have expired.

A required field might have been missed.

The external system might have failed.

For reliable autonomous systems, success should mean that the expected real-world state transition was verified — not simply that an action was attempted.

That distinction becomes increasingly important as AI systems move from generating information to taking real actions.

Models Are Only One Part of the System

AI models will continue to improve.

They will also change.

Different models may be better suited to different tasks, and today's best model may not be tomorrow's.

This suggests an interesting architecture:

Treat models as interchangeable intelligence engines while keeping the persistent execution lifecycle outside the model.

The durable system owns the mission.

The model helps reason about it.

What We're Exploring With Omecra

This is the idea behind Omecra — an AI Operating System.

We're exploring how AI systems can continuously work toward real-world goals across model calls, tools, failures, restarts, and changing external conditions.

The first problem we're applying this idea to is job search.

Instead of repeatedly searching across platforms and manually managing every step, the goal is to move toward a system where a user defines what they want and the system continuously works toward that outcome.

Job search is only the starting point.

The broader question is much bigger:

What happens when AI stops being something you repeatedly prompt and starts becoming a system that can reliably continue working toward a mission?

That's the direction we're exploring with Omecra.

I'd be interested to hear how other developers are thinking about persistence, verification, and recovery in autonomous AI systems.

— Deepak Patidar

Founder & CEO, Omecra