Engineering capacity, without the hiring friction
Top-tier engineers.Built around your work.
Hire in days, not weeks or months.
Senior generalists from Kathmandu who ship end to end and work with AI agents every day. The tools make them quicker. Their judgment is what you are hiring.
Engineers in Nepal · US and Australian teams · You interview and decide



Illustrative portraits of the engineers we vet and place.
Friendly, curious and good at what they do. They join your standup, not a ticket queue. And they're used to being the new person in a working codebase: they read the room before they rewrite it.
- Cursor
- Claude Code
- GitHub Copilot
- Your stack
A day inside your team
- 09:30Standup. Yesterday in two sentences, one blocker, no status theatre.Your team
- 11:00Pairs with your tech lead on the approach for the next feature.Human
- 14:00Lets an agent write the tests and boilerplate, then reads every line.AI speeds it up
You don't get a CV.
You meet a person.
Warm, direct and senior. The engineers we put in front of you can explain what they've built, why they built it that way, and what they'd do differently next time. The profiles below are illustrative examples of the engineers we vet and place, not bios of named staff.

Example profile
Barsha
Senior generalist, backend-leaning
I like the unglamorous parts: the data model nobody wants to touch, the endpoint that has to survive real traffic.
- Strongest at
- APIs, data modeling, cloud cost
- Daily AI tools
- Claude Code · Codex · Cursor

Example profile
Binod
Senior generalist, platform-leaning
If it can't be deployed, rolled back and monitored, it isn't finished. That's the whole philosophy.
- Strongest at
- AWS, CI/CD, reliability
- Daily AI tools
- Copilot · Cursor · Claude Code

Example profile
Nabin
Senior generalist, data-leaning
I've watched enough dashboards lie to want the ones that tell the truth, even when it's uncomfortable.
- Strongest at
- Data pipelines, RAG, evals
- Daily AI tools
- Claude · Codex · Aider
Your roadmap doesn't
wait for hiring.
You have the work. The difficult part is finding someone good enough to do it without spending weeks searching, screening and interviewing. Most teams solve this by lowering the bar, stretching the timeline, or handing the gap to whoever has spare capacity. It rarely ends well.
The work is waiting
Features, bugs, technical debt, customer requests. Your roadmap keeps moving while the role stays open. The work doesn't pause for the hiring process. It piles up in the backlog, on the people already carrying the load, and in the queue of things your customers were told to expect next.
Hiring is eating your time
Writing the role, sourcing, screening, interviews, references, notice periods. Your senior people are doing it instead of building. Every hour spent reading CVs is an hour not spent on architecture, code review, or the product decisions only they can make. The longer the search runs, the more it costs you twice: once in time, once in the work that waited.
The wrong hire is expensive
A weak engineer adds management overhead, rework and friction. More work, not less. The wrong person doesn't just fail to add capacity, they consume it. Someone has to review more closely, explain more often, and repair what slipped through. That's the outcome nobody budgets for when they open the role.
That's the part we handle.
The hiring process alone costs you weeks.
Every single time.
This is the part nobody quotes for and every team rebuilds. Weeks gone before the real work starts. Before a single line of your code is touched, the process eats writing, scheduling, screening and waiting. And the cost isn't just the calendar. It's the momentum a team loses while the role sits open.
- Writing the job description
- 3 days
- Posting and sourcing
- 1-2 weeks
- Screening CVs
- 1-2 weeks
- Interview loops
- 2-3 weeks
- Offer and sign-off
- 1 week
- Notice period
- 4-8 weeks
- Onboarding and ramp-up
- 2-4 weeks
- Total
- 12-20 weeks
...role still open
AI makes them faster.
Experience makes them useful.
We do not sell AI. We place people who use it well. Every engineer uses AI coding agents daily and can add AI features to your product when the roadmap needs them. The tools are the easy part to acquire. Knowing when the tool is wrong is the part you are hiring.

The engineer owns
- Judgment: what to build, what to skip, and what to question before it costs a sprint
- Code review, and the final word on what merges
- Talking with your team, in your tools and in your standup
- Following the work into production, and owning what happens next
AI speeds up
- Boilerplate, scaffolding and repetitive refactors, done in a fraction of the time
- First drafts of tests and documentation, before the engineer improves them
- Exploring unfamiliar code and libraries without burning a day on it
- AI features for your product: model APIs, RAG, evals, guardrails
Every AI-drafted change is read, tested and owned by the engineer who merges it. Nobody ships output they can't defend in review. That is the difference between a faster team and a faster mess.
How you end up
with the right engineer.
Five steps. Four of them are ours. You spend your time on the one that matters.
- 01
Your need
We start with the role, the stack, the product and the team the engineer would join. The better we understand the work, the fewer wrong conversations follow, so we ask about the codebase, the rituals, and the kind of problems that actually eat your team's week.
Day 1 - 02
We source
We go and find engineers relevant to that actual work. Nobody is waiting on a bench. We reach into our network in Nepal, talk to people who build the kind of systems you run, and only bring forward the ones whose experience maps onto your stack and your problem.
In days - 03
We vet
Technical ability, real experience and communication: assessed before you spend any time. A real problem, their code, our questions, and a hard look at how they explain their own decisions. If the reasoning doesn't hold up, you never hear the name.
We ask how they use AI agents, and when they distrust them.
In days - 04
You meet
You interview. You decide. The hiring decision stays yours. You get the engineer we'd pick, with what we saw and what we weren't sure about, so the conversation starts where it should: with the work.
Ask them to show their AI workflow live.
Your call - 05
They join
They work inside your team, your codebase and your process. Your standup, your review standards, your definition of done. From the first week the goal is simple: ship something real, inside your rules, with no special treatment in either direction.
We check in with both sides after the hire.
Same week
Not more CVs.
More signal.
We don't win by sending you a pile of candidates. We win when the people you meet are actually worth meeting. Every profile you see has already been through everything below. The six signals are the short version of a long process, and they're why the list is short.
Relevant experience
They've worked on software close to yours. Not the same product, but the same shape of problem, the same moving parts, and the same failure modes worth knowing about in advance.
Technical ability
Assessed on a real problem, not a quiz. We watch how they work when the answer isn't obvious, because that's the situation you're actually paying them for.
Stack alignment
Comfortable in the tools your team already uses. Deep in the core of your stack, honest about the corners they'd need to learn, and quick to learn them.
Communication
Can explain a decision, and disagree without drama. They'll be in your standup and your review threads, so how they write and how they push back matters as much as what they build.
Team compatibility
Fits the way your team actually works.
Ownership
Follows the work into production and cares what happens after. The merge isn't the finish line. They watch what their code does when real users find it.
You meet engineers worth meeting.
They join your team.
They don't sit beside it.
Your engineer works inside your roadmap, your codebase, your communication and your engineering standards, not in a separate delivery bubble. No parallel process to manage, no translation layer between you and the work, and no second definition of done. They commit to your repos, attend your planning, and answer to your technical leadership from the first week.
- Your roadmap
- Your codebase
- Your tools
- Your sprint process
- Your standards
- Your technical leadership
We don't disappear
after the hire.
The placement is the beginning of the relationship, not the end of it. We stay close enough to both sides to catch problems while they're still small, and honest enough to raise them before you have to. Good engagements should get better over time. That only happens if someone keeps asking.
Join
The engineer starts inside your team. Your tools, your standup, your standards. Onboarding is short by design, because we picked someone who has done this kind of work before.
Check in
We talk to both sides, not just to you, and not just once. Early conversations surface the small frictions that never make it into a status report.
Feedback
Is the contribution landing? Is communication working? Is the workload right? We ask specific questions instead of waiting for something to go visibly wrong.
Improve
We fix what's off, early, while it's still small. Sometimes that's coaching, sometimes it's a hard conversation, and occasionally it's a change of engineer. Whatever it is, you hear it from us first.
If something isn't working, we want to know early.
One engineer.
Or a team.
Start with one great engineer. Scale into a team when the work requires it. One monthly fee covers payroll, taxes and benefits, devices, and secure access to your systems, so the only thing you manage is the work.
One Engineer
One senior AI-fluent generalist joins your existing team, your tools and your standup, and starts shipping inside it. Not a consultant who advises from the edge, and not a contractor who needs the work cut into pieces. A working engineer, in your repos, on your problems.
Embed an engineerBest for
- A role you can't fill
- Feature delivery
- Backend / frontend capacity
- Platform work
- A specialist skill
Team
Depth across roles, for example backend, AI features and ops, as a small embedded team under your technical direction. You interview and decide. The shape follows your roadmap rather than a fixed org chart, and every engineer in it clears the same bar as the solo hires.
Embed a teamBest for
- Growing roadmaps
- Major features
- Parallel workstreams
- Scaling an existing team
Custom offer
Something else in mind?
Part-time hours, a specific stack, a fixed-scope sprint, or a second opinion before you commit. Tell us the shape of the work and we will say honestly whether we are the right people for it.
An honest answer, within one business day.
We're young. Our experience isn't.
Decimal is a small, founder-led company, about a year old. The four of us have spent years inside software teams and technology businesses, long enough to have hired badly, hired well, and learned the difference. The company is new. The people running it aren't.
We find and vet engineers in Nepal, and we place them inside teams that need the capacity. That's the whole company. No bench to fill, no account managers between you and the decision, and no pile of profiles hoping something sticks. We find the person, stand behind them, and stay close after they join.
We're ready for the work.
A bit more about usQuestions people ask
before they hire.
Short, direct answers. Ask us anything else on a call.
How fast can I hire a senior engineer through Decimal Tech?
Decimal Tech aims to put an interview-ready senior engineer in front of you in days, not the weeks or months a normal search takes. You interview and decide, and the engineer can then join your team the same week.
What does "AI-powered engineer" mean at Decimal Tech?
It means two things. The engineer uses AI coding agents such as Cursor, Copilot and Claude every day to write, review and ship software, and can build AI product features when needed, including model APIs, RAG, evals and guardrails. We do not claim ML research expertise.
Who owns the hiring decision and the work?
You do. You interview candidates and make the hiring decision. The engineer then works inside your team, your codebase and your process, under your technical direction. Decimal Tech checks in with both sides after the engineer joins.
What does the monthly fee cover?
One monthly fee covers payroll, taxes and benefits, HR, devices and secure access to your systems. Engineers work from our Kathmandu engineering centre in Nepal, so you do not manage local employment, equipment or compliance yourself.
Where are Decimal Tech engineers based?
Engineers work from our Kathmandu engineering centre in Nepal, and we serve teams in the United States and Australia. Kathmandu's morning is Melbourne's afternoon, so Australian teams get three to four hours of live overlap every day; US teams meet Kathmandu in their evening. Decimal Tech LLC is headquartered in Denver, Colorado, and Decimal Tech Pvt. Ltd. operates the Kathmandu engineering centre. Engineers work in your tools and rituals.
When should I hire a team instead of one engineer?
Hire one engineer to fill a role or clear a backlog. Hire a team when you need depth across roles, for example backend, AI feature work and ops, as a small embedded group under your technical direction. Most clients start with one engineer.
Have the work.
Need the engineer?
Tell us what your team needs. We'll help you find the right engineer, and you'll interview them before anything is decided. If we don't have the right person, we'd rather tell you that than sell you the wrong one.
Talk to a founder, not a salesperson. A direct reply, within one business day.
We're ready for the work.