Backend development services that ship real systems, not slideware
Full Scale is a backend development company that delivers custom backend development across Node.js, Python, Java, Go, and .NET: REST, GraphQL, and gRPC APIs, microservices, database engineering, event-driven systems, and backend modernization. We staff senior Filipino engineers who join your team and stay on your codebase, including the engineers powering enterprise systems at AMC Theatres. You direct the work; we handle hiring, payroll, and HR. Fully loaded from $35/hr, with your first sprint in 7 days.
@Controller('orders')
export class OrdersController {
constructor(
private readonly orders: OrdersService,
) {}
@Post()
async create(@Body() dto: CreateOrderDto) {
return await this.orders.create(dto);
}
}Backend teams trusted by enterprises, scale-ups, and Fortune 500s
Previously founded VinSolutions ($150M+ exit) and Stackify
I have always been more of a backend developer
Full Scale is a backend development company built around senior Filipino engineers and the Product Driven framework. My first language was .NET, but the work I care about lives on the backend: the database, the scheduled services, the queued operations, and the APIs that hold up under real traffic. At Stackify we built an APM product that processed billions of data points every day, instrumenting the event loops, query plans, and external calls of thousands of customer backends. Years of staring at production traces from real systems at real scale teach you what actually breaks, which is a faster education than any tutorial.
We have hired hundreds of backend engineers in the Philippines since 2018 across Node.js, Python, Java, Go, and .NET. We test them on real architecture problems rather than syntax quizzes, and we have built dedicated backend teams for fast-growing SaaS companies and for AMC Theatres. When the engagement is a full SaaS build, see our SaaS development company page. If you need backend development services from a team that actually builds things, rather than a vendor that subcontracts the work, you are in the right place.
Five things we believe about building backends that last
Backend development services are a commodity in plenty of places. What separates the work that holds up from the work that gets rewritten in eighteen months is judgment about a handful of things. These are the arguments that decide whether your backend survives real traffic, and they hold up in production rather than in a vendor slide deck.
The backend is where the work that lasts gets done
Changing a UI is cheap. Reworking a backend after the fact is expensive, and most teams find that out the hard way. The data model, the service boundaries, the API contracts, and the queues are the decisions you live with for years, so they deserve senior engineers who have made them before. That is the part of software our bench is built to own.
Pick the stack for the workload, not for the resume
Node.js for IO-bound, high-concurrency APIs and real-time feeds. Python for data and ML-adjacent work. Java and Go for throughput and distributed systems. .NET for enterprise systems already invested in Microsoft. Our backend developers span all of them, so the recommendation you get is based on your problem rather than the one language a single-stack shop happens to staff.
Distributed systems are hard, and that is the point
Retries, idempotency, exactly-once-ish delivery, backpressure, and eventual consistency are where backend engineering separates from CRUD. A junior gets the happy path working; a senior engineer designs for the partial failures that take production down at 2 a.m. We hire for that judgment specifically and test it before anyone reaches your team.
The data layer is usually the real bottleneck
Most slow backends are not slow because of the language. They are slow because of an N+1 query, a missing index, a chatty ORM, or a schema that never anticipated the access pattern. Our backend developers treat database design and query tuning as first-class engineering across Postgres, MySQL, SQL Server, MongoDB, Redis, and DynamoDB, not an afterthought.
Engineers who stay long enough to own it
Backend quality compounds with tenure. The engineer who designed the schema knows why the service boundaries fall where they do and where the operational debt is buried. Offshore backend done through freelancers rotating off every six weeks never builds that knowledge. Our 93%+ annual retention is what makes dedicated backend ownership actually possible.
AI-powered backend engineers, trained on Product Driven principles
Most backend teams adopting AI are shipping more code without shipping better software. The slop volume climbs, production incidents follow, and engineers whose only skill is typing faster end up costing more in cleanup than they save in keystrokes.
Full Scale backend developers are trained on something different: the Product Driven approach from Matt's book, combined with the full modern AI toolkit (GitHub Copilot, Claude, Cursor). They think first, type second, and use AI for the parts where judgment doesn't add value, like scaffolding an API, generating test coverage, or optimizing a slow query. That combination is rare, and it is what serious backend teams should actually be hiring for in 2026. When the work shifts from backend services to LLM apps and agents, you can also hire AI engineers from the same bench.
Product Driven engineering
Our engineers are trained on the five pillars from Matt's book: Vision, Focus, Clarity, Ownership, and Courage. The result is developers who push back on bad product decisions, ask whether a ticket should exist before writing it, and own the outcome of what ships. They are not order takers.
Read Product Driven, the bookAI as a thinking partner
Every backend engineer on our bench works with GitHub Copilot, Claude, and Cursor every day. They use AI to scaffold API endpoints and boilerplate, generate test suites, draft the first cut of a tricky SQL query before tuning it by hand, and review their own pull requests before a human ever sees them. Judgment stays with the engineer, the grunt work moves to the machine.
AI without product thinking is just an AI slop machine, and the backend engineers I want on my team don't get caught by that. They reason about the system before they reach for Copilot, and they use AI for the parts where judgment doesn't matter. That's who we hire and train at Full Scale.
The engineering team behind AMC Theatres
Custom Backend Development Services
A greenfield API, a monolith broken into services, an event backbone, a slow query nobody has chased down in six months: our engineers ship across all of it in Node.js, Python, Java, Go, and .NET. The difference is how we deliver. Every one of these custom backend development services runs through staff augmentation, so you get senior backend engineers embedded in your team and billed for engineering hours rather than a fixed-bid project shop that disappears at handoff. Here are the backend development services we get hired for most often.
REST, GraphQL & gRPC API development
We design REST APIs with OpenAPI contracts, GraphQL with Apollo or Strawberry, and gRPC for internal service-to-service calls. Third-party integrations get circuit breakers, exponential backoff, and idempotency keys, so your API layer holds up when a downstream vendor falls over. Typical engagement: a versioned API and contract tests in CI, built in Node.js or Python and shipping in the first sprint.
Hire dedicated API developersMicroservices & distributed systems
We decompose monoliths into services with sane boundaries, or build distributed systems from scratch in Go and Java when throughput and isolation matter. The hard parts are retries, idempotency, backpressure, and consistency, and we hire backend developers who design for partial failure rather than the happy path. Typical engagement: a service extracted from a monolith with its own data store and a clean contract, behind a feature flag.
Database design & data engineering
Schema design, indexing strategy, query optimization, and migration management across Postgres, MySQL, SQL Server, MongoDB, Redis, and DynamoDB. When the bottleneck is the data layer, we build pipelines, ETL, and reporting stores in Python or Java that finance can actually sign off on. Typical engagement: an N+1 audit and indexing pass that cuts a slow endpoint from seconds to milliseconds.
Hire dedicated database developersReal-time & event-driven systems
Event-driven backends with Kafka, RabbitMQ, SQS, and EventBridge, plus WebSocket and Server-Sent Events layers for live dashboards and feeds. We build the consumers, the dead-letter handling, and the replay logic, not just the producer. Typical engagement: an event backbone in Node.js or Java that decouples your services and survives a downstream outage without losing messages.
Cloud infrastructure & DevOps
Containerized backends on AWS, GCP, and Azure with infrastructure as code, CI/CD pipelines, observability, and the serverless options (Lambda, Cloud Run, .NET on Functions) when a workload fits. Our engineers own the deploy path, not just the code that runs on it. Typical engagement: a Dockerized service on ECS or Kubernetes with Terraform, tracing, and a pipeline your team can actually read.
Backend modernization & migration
We run production backend modernization projects: monolith decomposition, .NET Framework to .NET 8, Python 2 to 3, on-prem to cloud, and re-platforming off legacy stacks. We know which libraries break, where the global state is buried, and how to stage the cutover so the business does not stop. Typical engagement: a phased migration with the old and new paths running side by side until the cutover is safe.
How we modernize legacy backendsEight backend specializations, one staffing partner
Most backend teams need more than one role. You can staff backend engineers, API specialists, microservices architects, database engineers, and DevOps from a single vetted bench, and mix the stacks and seniorities as the project requires. The same bench staffs dedicated backend developers across Python, Java, .NET, PHP, Ruby, and Go when a project needs more than one language. When the API needs an owner on the UI side too, the same bench staffs dedicated frontend developers who pair cleanly with your backend engineers on shared standups. And when the bottleneck turns out to be the data rather than the code, you can hire dedicated database developers who own the schema, indexing strategy, and migrations alongside the rest of the team.
Backend Engineers
Senior generalists who own the API layer, business logic, and data access. They are fluent across Node.js, Python, Java, Go, and .NET, and the core skills carry, so they can pick up an unfamiliar framework in a week because the fundamentals travel.
API Engineers
Engineers who design REST, GraphQL, and gRPC APIs as contracts first and code second. They reason about versioning, idempotency, pagination, and error semantics before they write a route handler, and document everything with OpenAPI.
Microservices Architects
Engineers who decompose a system into services, pick sync or async communication on purpose, and handle distributed transactions with saga orchestration and the outbox pattern. They also know when a modular monolith is the better call.
Database Engineers & DBAs
Engineers whose primary discipline is the data layer: schema design, query tuning, index strategy, and migration management across PostgreSQL, MySQL, MongoDB, and Redis. The people you want when the bottleneck is the data, not the code.
DevOps & Platform Engineers
Engineers who cover CI/CD on GitHub Actions or GitLab CI, containers and Kubernetes, infrastructure as code with Terraform, and observability. They make backend releases boring in the good way and keep the platform stable under load.
Data Engineers
Engineers who build the pipelines that move and shape data: batch and streaming ingestion, ETL and ELT, warehousing on Snowflake or BigQuery, and the event streams that feed analytics and machine learning downstream.
Staff / Lead Backend Engineers
Senior engineers who can run a backend team, set the architectural bar, and lead code reviews without becoming the bottleneck. They make the calls on patterns, push back on bad decisions, and own the outcome of what ships.
Integrations Engineers
Engineers who connect your backend to everything around it: payment processors, third-party APIs, webhooks, message queues, and legacy systems. They handle retries, rate limits, and partial failures so the integrations hold up in production.
Real backend engineers, named and vetted
A sample of the backend engineers on our team. These are real Full Scale developers working remotely from across the Philippines, and you'll meet candidates like them during your interview round.
A back-end developer who ships production work with C#, .NET Framework, and .NET MAUI.
A senior back-end developer with 13 years of experience across Node.js, PHP, and CSS.
A senior back-end developer with 10 years of experience across C#, Java, and Python.
A senior back-end developer with 13 years of experience across C#, .NET MAUI, and Xamarin.
A back-end developer who ships production work with C#, Java, and Python.
A back-end developer who ships production work with Node.js, PHP, and Angular.
Architecture patterns our backend engineers apply in production
Most offshore shops deliver a working application at handoff. What determines whether it is still working and maintainable 18 months later is the architecture decisions made in the first sprint. These are the patterns our engineers reach for across every backend stack, and the reasoning behind when each one earns its complexity.
Modular Monolith
One deployable, cleanly separated into modules with their own boundaries. It ships faster than premature microservices, is far easier to debug, and gets most teams surprisingly far before they ever need to split anything out. We start here unless there is a real reason not to, and we will tell you when that reason shows up.
Microservices & Distributed Systems
Service decomposition, sync versus async communication chosen on purpose, distributed transactions via saga orchestration and the outbox pattern, and tracing across service boundaries. We reach for this when independent scaling and separate failure domains earn the complexity, not because a diagram looks impressive.
Event-Driven & CQRS
Async work pushed onto a queue or an event stream, with read and write models split when each needs to scale on its own terms. We implement it on Kafka, RabbitMQ, or SQS depending on the throughput and the delivery guarantees the system actually needs, and we keep it as simple as the problem allows.
API Gateway & BFF
A single entry point that handles routing, auth, rate limiting, and request shaping, with a backend-for-frontend layer when web and mobile clients need different responses from the same services. It keeps cross-cutting concerns out of every individual service and gives clients a clean contract to build against.
Caching Layers Done Right
Caching designed deliberately, with the invalidation strategy planned alongside the read path instead of bolted on later. We choose the layer per access pattern, in-process, Redis, or a CDN, and we treat cache invalidation as part of the feature, because a cache with no invalidation plan is just a stack of phantom bugs waiting for 3am.
Queue-Based Processing
Slow and unreliable work moved off the request path and onto background workers with retries, dead-letter queues, and idempotency keys so a duplicate message never charges a customer twice. The user-facing API stays fast while the heavy lifting happens behind a queue that can absorb a spike without falling over.
Opinionated takes on backend architecture from engineers who ship it
Most vendors tell you their favorite stack is the right choice for everything. We will tell you when it is not. These are the actual opinions we hold from building and operating backend systems in production across Node, Python, Java, Go, and .NET, not talking points from a sales deck.
We pick the language for the problem, not for the resume. Node.js wins on IO-bound APIs that fan out to databases and third-party services, and on teams that want one language across the front and back. Python wins where the data and machine-learning libraries are genuinely ahead. Go and Java earn their place on CPU-heavy work and high-throughput services where a compiled runtime's predictable performance matters. We will tell you which one fits before we staff it, even when the honest answer is not the stack you walked in expecting.
Most teams reach for microservices years before they need them, then spend the next year paying for it. A well-modularized monolith ships faster, is easier to debug, and gets you surprisingly far. We split a system into services when there is a real reason: independent scaling, separate failure domains, teams that need to deploy on their own cadence. Twelve services sharing one database is not microservices, it is a distributed monolith with extra steps, and we will say so.
We ship validation at the boundary, real error handling, idempotent writes, and dependency injection so the code stays testable. We refuse business logic stuffed into route handlers, N+1 queries that nobody checked the query plan for, retries with no idempotency key, and caching with no invalidation strategy. We treat database migrations as reversible and staged, never as a one-shot script run against production by hand.
Big-bang rewrites that try to replace a whole platform in one release instead of strangling it module by module. Legacy modernizations that lift and shift onto new infrastructure without touching the architecture, so the same bottlenecks come along for the ride. Service splits that keep a shared database, so you inherit the operational cost of microservices with none of the isolation benefit. We migrate in stages you can roll back, and we keep the old system running until the new one has actually proven itself in production.
From first call to production: how a backend project runs at Full Scale
Staff augmentation without a delivery framework is just headcount. Here is what the engagement actually looks like from the first conversation to a deployed production system and the ongoing work that comes after.
We scope the engagement together: what to build first, what specializations to staff, what the first sprint should deliver. You walk away with a staffing plan and a candidate shortlist, not a 40-page requirements document.
You interview our pre-vetted candidates and select who starts. We handle employment, payroll, and equipment setup on the Philippines side. Your engineer gets access to your repo, your tools, and your standups. First commit typically happens within the first week.
Your engineer works in your sprint cadence, under your tech lead, committing to your repo. You see the work in progress, not at a scheduled demo. Architecture decisions happen in your standups, not behind a project management wall. The sprint velocity is yours to direct.
Our engineers write tests as part of delivery, not as a post-sprint cleanup task. They write unit tests in whatever framework the stack uses (Jest, pytest, JUnit, Go's testing package, xUnit, RSpec, PHPUnit), integration tests against real dependencies, and contract tests for the APIs other services depend on. AI-assisted PR review with Copilot or Cursor runs before human review. Code that ships is code that has been tested.
Your engineers own the production deployment: infrastructure as code, observability from day one (OpenTelemetry, Datadog, or equivalent), and runbook documentation for the most likely failure modes. They stay on after launch. Post-launch bugs go into your backlog like any other work, not into a 'warranty period' clause in a contract.
How a backend development project starts at Full Scale
You don't pay for a discovery phase before a line of code is written, and you don't sit through a six-week RFP process. We scope the work in a single call, assemble pre-vetted backend engineers from the bench, and have code shipping in the first week.
Scoping call
30 minutes. We learn what needs to be built, what's already in the codebase (if anything), which languages and frameworks the project runs on, what the first sprint should deliver, and what backend specializations it needs. We don't pitch on this call. We scope the work with you.
Team assembly
We pull 1–3 pre-vetted backend engineers whose language, framework, seniority, and prior project experience match what the project requires, whether that's Node.js, Python, Java, Go, .NET, Ruby, or PHP. You see their full profiles and actual project history before the interview.
Technical interview
You interview candidates the way you would any senior hire: live system design, API and schema design, database and query-plan reasoning, distributed-systems and concurrency depth, and the framework specifics for the stack you run. Pass on anyone you don't believe in, and we keep looking.
Contracts & setup
One contract with Full Scale. We handle all employment, payroll, equipment, and HR logistics in the Philippines. Your engineer gets repo access, tool access, and sprint 1 is planned.
First delivery
Your engineer joins your standups, commits to your repo, and ships code in the first week. Our delivery team stays in the loop through ramp-up to make sure velocity doesn't stall. They own the work through launch and beyond.
Writing backend code is not the same as running a backend in production
Anyone can stand up a CRUD API that works for five minutes. Operating a backend that holds up under real traffic, real data volumes, and real failure modes requires a different bench entirely. When you outsource backend development or hire offshore backend developers, this is the gap that decides whether the project ships. Our senior, dedicated engineers stay on your team long enough to own what they build, which is what closes that gap. Here is what we test for, and what most offshore staffing companies skip.
APIs that work in the demo and fall over under load
Junior backend developers ship endpoints that pass on a laptop with five test rows, then time out the first time real traffic hits them. There are no connection pools sized for production, no pagination on the list endpoint, no thought given to the N+1 query. Our engineers design for the load the system will actually see, because they have run services that took it.
No observability until production is already on fire
When something breaks at 3am, the difference is whether the team can see what happened. Cheap offshore teams ship code with no tracing, no structured logs, and no metrics, so every incident turns into guesswork. Our engineers wire up OpenTelemetry, dashboards, and alerts as part of building the feature, not as a cleanup project after the first outage.
Data migrations that corrupt or lock the table
A brittle migration takes a write lock on a hot table during business hours, or ships a schema change with no backfill plan and no rollback. Senior backend engineers treat migrations as a discipline: reversible, run in stages, tested against production-shaped data first. Most offshore developers have never had to migrate a table that real customers were writing to.
Security gaps in auth that nobody catches
Backend security is where the worst bugs hide: broken authorization that lets one tenant read another tenant's data, JWT validation that trusts the token's own claims, secrets committed to the repo. We screen for engineers who understand the real attack surface of a production API, not ones who treat security as a checklist at the end of the project.
Microservices sprawl that should have stayed a monolith
Cheap teams reach for microservices because it looks impressive, then hand you twelve services that share one database and fail together. You inherit the operational cost of a distributed system with none of the isolation benefit. Our engineers decompose a system only when it earns the complexity, and they will tell you when a modular monolith is the right call.
Production debugging nobody on the team can do
A senior backend engineer can read a flame graph, trace a request across services, debug a deadlock from a Postgres log, and reason about why a queue is draining slower than it fills. With staff augmentation, the engineers who own these problems are the same ones who built the code, so they have both the context and the incentive to fix it right.
Backend expertise tuned to your industry
As a backend development company that has been around for over a decade, we have placed dedicated engineers into nearly every industry that ships software. Domain knowledge cuts onboarding time in half, so we match developers to projects where they have already shipped real code, in the language that project runs on.
SaaS & Scale-ups
B2B SaaS backends are our home turf. Our engineers have shipped multi-tenant architecture, subscription billing through Stripe, role-based access, and webhook delivery infrastructure in Node.js, Python, Java, and .NET. They have worked on SaaS platforms at every scale, from seed-stage to public companies, on whatever language the product was built in.
From Node and Python to Java, Go, and .NET
Whether you want backend engineers for a high-throughput API, a Python service behind a heavy data pipeline, a Spring Boot platform, or a legacy modernization that has to keep running while you migrate, the bench covers every layer of the modern server-side stack. Pick what you need. We will match a backend developer who is genuinely fluent in it.
Hire dedicated backend developers, two ways
Most clients start with a single dedicated backend developer and grow into a full team. Either way, you get full-time engineers who sit on your standups, work your hours, and ship code against your roadmap across Node.js, Python, Java, Go, .NET, Ruby, and PHP. Both options run on our staff augmentation model at the core: dedicated, long-term engineers embedded in your team rather than freelancers, shared resources, or a project shop on the side. See the full breakdown of how we hire dedicated backend developers across every engagement we staff. When a backend hire also needs to build the UI on top of the API, you can hire full stack developers from the same bench. And when the workload moves toward high-concurrency services that have to run cheaply under load, you can hire dedicated Golang developers under the same engagement model.
Dedicated developer
Full-time, exclusive, sits on your standups.
- Full-time backend engineer assigned only to your project
- Works your hours, your tools, your codebase
- Joins your standups, reports to your tech lead
- We handle payroll, HR, equipment, retention
- Replace within 30 days if it isn't a fit
Dedicated team
Multiple engineers, embedded as a pod.
- 2-10 backend engineers staffed together as one pod
- Optional QA, DevOps, and tech lead included
- Operates as a team inside your engineering org
- Scale up or down by a head with 30 days notice
- Account manager you can escalate to in the US
Dedicated backend developers, starting at $35 an hour
That rate is fully loaded. Every engineer we staff on your backend project is a senior developer in the Philippines working full-time under your direction, and we cover the payroll, benefits, HR, and equipment. The same role hired locally in the US runs $150K to $200K a year for a senior backend engineer, more for distributed systems or real-time experience, which is the delivery math that brings most teams to the table.
- Full-time, dedicated backend engineer
- Pre-vetted by senior backend reviewers
- Works your hours, your tools, your codebase
- Payroll, HR, equipment, benefits handled by us
- US-based account manager you can escalate to
- 30-day replacement guarantee if it isn't a fit
Full Scale has made the Inc. 5000 four years in a row and is Great Place to Work certified. We have been doing this since 2018, and pricing isn't the only reason clients stay with our backend development company, it's the easiest reason to call.
Why we deliver backend projects from the Philippines
Every backend project we deliver is staffed from the Philippines. You can also hire dedicated developers in the Philippines across every other stack we work in, with the same vetting bar, retention, and engagement model that backend clients get.
English-fluent by default
The Philippines is the third-largest English-speaking country in the world. Standups, code reviews, and customer calls work the way they do with any US team member.
Real time-zone overlap
Most of our backend engineers work US business hours with 4-8 hours of real-time overlap with East and West Coast teams, so decisions happen live during shared hours rather than crawling through 24-hour async handoffs.
Deep backend talent pool
Cebu and Manila produce tens of thousands of CS and IT graduates a year, trained across Java, Python, .NET, and Node, deep enough to staff a full backend project team without compromising on seniority. The country has been a software outsourcing home for over a decade.
Cultural alignment with US teams
Filipino engineers grow up on US business norms, US TV, and US tech culture, so agile rituals, direct feedback, and collaborative workflows feel familiar from day one. These teams integrate fast rather than needing constant management.
Backend development services vs the other ways to get backend software built
Every backend delivery model has a different set of trade-offs. Fixed-bid agencies offer a contract; consultancies offer a proposal. Working with a staff augmentation company gets you engineers who embed in your team and work under your direction from day one. Here is how those models compare on the things that actually determine whether a backend project succeeds.
| Factor | Full Scale (staff aug) | Fixed-bid agency | Consultancy / SI | Build in-house |
|---|---|---|---|---|
| Time to first sprint | 7 days | 4-8 weeks | 6-12 weeks | 3-6 months |
| You control architecture decisions | ||||
| Visibility into work in progress | ||||
| Engineers dedicated full-time to your project | ||||
| Scope flexibility when requirements change | ||||
| Budget predictability | ||||
| Engineers own what they ship post-launch | ||||
| You own all IP from day one | ||||
| Engineer continuity across the project | 93%+ retention | varies | low | varies |
| Fully-loaded cost vs US in-house team | ~40-50% | ~60-80% | ~100-150% | 100% |
The numbers behind a backend staffing partner that actually works
From the people we actually staff teams for
Full Scale's development team was pivotal in elevating our facility management software. Their expertise turned complex challenges into seamless functionalities, enhancing user experience and operational efficiency.
The team at Full Scale brought our vision to life with their development skills. They helped us navigate technical requirements with ease, resulting in a robust platform our users trust.
Deeper guides to offshore development and team building
Offshore development best practices
What separates the teams that ship from the ones that stall.
Offshore due diligence checklist
The questions to ask a partner before you sign anything.
Nearshore vs offshore
When each model wins, from a CEO who has run both.
Outsourcing vs offshoring
The distinction most CTOs get wrong, and why it matters.
What offshore development really costs
The real numbers behind offshore rates and total cost.
The ROI of offshore development
The math behind 50-80% development cost reductions.
Everything you wanted to know about backend development services
Get backend development services from a team that has actually built backend systems before
Book a 30-minute discovery call with the backend development company that delivers custom builds, API and microservice work, database engineering, and modernization through dedicated engineers from the Philippines. We will learn what you are building, walk you through which Node.js, Python, Java, Go, or .NET engineers are on the bench, and you will meet candidates within a week. Fully loaded from $35/hr, and the call is a working session rather than a sales pitch.