
From “Apply for Me” to a Submission Receipt: Building Career Agent on AWS
How we built a job-application agent with Strands and GLM-5 on Amazon Bedrock—and what broken forms, uncertain submissions, and shared Lambda capacity taught us.
From “Apply for Me” to a Submission Receipt: Building Career Agent on AWS
A student team's lessons in job discovery, browser automation, authorization, and recovering from uncertain outcomes.
My profile contained one university degree. The employer's application form had reached Education 5.
The same agent could explain why a job matched my resume, yet leave the degree dropdown empty and add another education section. On a different form, it tried to put text into a file-upload input and stopped with a browser error.
Those failures became the most useful part of building Career Agent during WeMakeDevs' First Commit hackathon. They forced us to examine every handoff between a request, a model response, a database record, a browser action, and an employer's confirmation.
What evidence should an application agent need before it can tell a person, “You applied”?
This article follows the architecture we built around that question, the mistakes that changed it, and the limits we still need to address.
The problem we wanted to solve
For students and early-career applicants, the administrative work repeats: search company career pages, check location and experience requirements, enter the same history, answer recurring questions, and remember which application needs attention.
We wanted one place to express an intention:
Find early-career software engineering roles in India. Check for new openings every hour. Prepare suitable applications using my verified profile.
Career Agent combines chat and voice, configurable job watches, resume-based match explanations, saved application answers, and a browser companion for supported employer forms. Users choose individual review or an automation mandate with eligibility rules, a score threshold, and a daily limit.
The useful outcome is an application the person understands and can track. Increasing the number of generated packets alone would tell us very little about whether we had helped.
The architecture follows the work

We divided the workflow into interpretation, persistent state, authorization, and execution. Each has a different failure mode.
Simplified implementation diagram. Arrows show responsibilities and key handoffs, rather than every deployed resource.
Responsibility | Implementation | Why it belongs there |
|---|---|---|
Receive a request | React, API Gateway, Lambda, Cognito | Authenticate the applicant and validate the request. |
Interpret and explain | Strands Agents SDK with GLM-5 on Amazon Bedrock | Turn language into typed tool calls and extract evidence for explanations. |
Remember and coordinate | DynamoDB, Streams, SQS | Preserve application state and continue work after the chat request ends. |
Revisit a search | EventBridge Scheduler and watch records | Check each watch's due time and configurable interval. |
Authorize an action | Cedar and transactional backend checks | Evaluate current permission, packet approval, eligibility, and limits. |
Execute a form | Lambda-hosted Playwright for the test portal; the signed-in browser companion for supported external forms | Keep the execution route explicit. |
S3 holds documents and frontend assets. Transcribe and Polly support voice input and spoken responses. SES supports application notifications. CloudWatch gives us the logs needed to investigate failures, while SAM and CloudFormation define the infrastructure.
Choosing a model we could actually access
Our AWS account was still completing verification, and only a subset of models was available to us. We selected GLM-5 on Amazon Bedrock and kept Strands as the agent framework. The deployed API and both worker configurations use:
Framework: Strands Agents SDKModel: zai.glm-5Endpoint: https://bedrock-mantle.us-east-1.api.aws/v1
The endpoint accepts an OpenAI-compatible API, so our Strands integration uses the corresponding client adapter. In this configuration, that adapter talks to Amazon Bedrock. The protocol label alone does not identify the hosting provider; the endpoint and selected model do. AWS's GLM-5 model card documents this endpoint and model ID .
Model access became an architectural constraint we could handle through configuration. We could continue building the workflow without embedding a particular model into every business tool.
Search needed structure before it needed more sources
One search bug was almost embarrassingly simple. A request for an internship could match a title containing “Internal.” A request for NVIDIA could return another company's posting because its description mentioned NVIDIA technology.
The text was present. The result still violated the request.
We separated employer, role, location, employment type, and work mode into structured filters. Employer names constrain the employer field. Location constrains location. Role matching uses word boundaries and aliases such as SWE and software engineer.
Freshness needs its own explanation too. A successful query with zero results, an unavailable source, and an older cached posting are three different observations. Reporting them as the same “no jobs found” answer hides the information a user needs to decide what to do next.
A relevance score is an explanation to inspect
Our matching model extracts evidence; backend code calculates the final score using a versioned rubric. The rubric allocates 40 points to skills, 30 to experience evidence, 20 to responsibilities, and 10 to preferences.
We check quoted passages against the actual resume text. We also keep missing requirements in the denominator: if a posting names five required skills, the model finding evidence for only three must not quietly turn the calculation into three out of three.
This does not establish that the applicant has mastered a skill. It establishes where the supporting claim came from, so the person can inspect it. The score is our fit rubric, not an employer's ATS score or a probability of getting an interview.
Eligibility is evaluated separately. A profile correction can change an experience or graduation check without requiring us to generate the entire model explanation again. We added that refresh after discovering that a stored “not eligible” result could outlive the profile facts that produced it.
Approval needs to describe the content being sent
An approval becomes ambiguous if the application changes afterward.
We store a versioned application packet and bind individual approval to its content hash. Changing the packet means checking approval again. Automatic mode uses a separate, expiring mandate and evaluates current conditions before dispatch.
permit (principal, action == Action::"submit_application", resource is Application)when { resource.owner == principal && context.mode == "auto_above_80" && context.mandate_active && context.auto_eligible && context.score > 80};
That is only one rule. Separate forbid rules cover incomplete required answers, exhausted daily capacity, pauses, current preferences, and unsupported submission routes. Backend code derives the context from stored state; the model does not supply its own permission facts.
The distinction matters at a boundary such as 80 versus 81. A user-facing promise about a threshold must have the same meaning in the interface, policy, and tests.
The browser taught us what “understanding a form” requires
Employer forms exposed details our first abstraction had missed:
Failure we observed | What the implementation needed to understand |
|---|---|
Text assignment to a file input stopped the run | A file control requires an actual file upload; optional transcripts and resume uploads are different fields. |
A saved B.Tech did not match a broad degree menu | Map a verified qualification to an unambiguous degree level without inventing a specialization. |
Repeated scans added education rows | Track record context and the approved record count; bound expansion attempts. |
The profile had the answer but the live form remained blank | Preserve question identity and context across the browser-to-backend request. |
The fixes combine semantic labels, record indices, saved answers, and control-specific handling. For a custom dropdown, text in a search box is insufficient: the browser needs to select an actual option. For an upload, the browser needs the document itself.
These details also explain the two execution routes. Cloud Playwright gives us a controlled test-employer environment. External application portals often depend on the applicant's authenticated browser, so the companion operates in that session. Login, MFA, CAPTCHA, unknown mandatory questions, and unsupported widgets can still require attention.
We have regression coverage for specific form behaviors. We are still working toward broader employer coverage; the browser integration is not universally reliable.
The moment after Submit is a distributed-systems problem

Imagine the employer accepts an application and the browser closes before our backend receives confirmation. Retrying the whole operation could create a duplicate. Marking it failed would also be an unsupported conclusion.
Dispatch records an attempted external action. Confirmation establishes the outcome.
Our workflow records a dispatch boundary before the final action. If confirmation is missing afterward, it can enter
OutcomeUnknown and follow a reconciliation path. A resumed browser session must inspect what happened instead of automatically clicking Submit again.The same care applies to internal queues. AWS documents that Lambda's SQS event source mappings can process records more than once . We use idempotency and a transactional outbox: the state update and the intent to perform background work are written together, then Streams and the relay deliver that work to SQS.
That pattern addresses a database-to-queue handoff. It does not create an atomic transaction with a third-party employer website. Keeping the uncertain outcome visible is how we preserve that distinction.
The concurrency change that made availability worse
Our account had ten concurrent Lambda executions available. To drain a background backlog faster, we raised worker concurrency to ten. Under load, those workers could occupy the capacity needed by the API.
We reduced the worker allowance to five to leave capacity available to other functions. The corrective commit records the mistake. Five is a setting for that account and workload, not a general recommendation.
The lesson was that queue throughput and interactive availability share a capacity budget. We subsequently worked on separating interactive traffic from scheduled searches. A faster worker configuration is useful only if the rest of the application remains responsive.
Parallel scoring also exposed contention on DynamoDB usage counters. A transient transaction conflict needed a bounded retry; a failed quota condition needed to stop. We preserved cancellation reasons and added bounded retry handling rather than treating every transaction failure identically. The fix and DynamoDB transaction documentation show why the distinction matters.
What the evidence supports today
Our 20 September CI and deployment run passed the backend suite, browser-worker checks, frontend build, and deployment smoke test. Browser tests cover targeted behaviors such as custom choices, repeated records, delayed navigation, saved-answer recovery, and reconciliation after dispatch.
Those checks have a specific scope. A browser fixture passing does not establish that a live Amazon, Google, Stripe, or Workday application succeeded. A fictional test-employer receipt demonstrates that test environment's workflow. A separate hosted walkthrough stopped for missing information before a receipt could be verified; that run remained incomplete.
We are also not claiming measured time savings, higher interview rates, or universal employer support. Those require broader user testing and outcome data. Discovery coverage, browser compatibility, model quality, and operational capacity remain active areas of work.
Our next evaluation should report completion rates by employer and form type, how often people must intervene, recovery after a pause, and duplicate-prevention behavior. A single overall “agent success rate” would hide too much.
What we are taking into the next build
Career Agent taught us to ask a more precise question at every stage: what does this state prove?
A match needs supporting evidence. Approval needs a defined packet or mandate. A background task needs durable intent. A browser action needs an outcome. When evidence is incomplete, the interface needs to say what remains unknown.
We built the project as a team: Souvik Ghosh led the architecture, backend, integrations, and deployment; Soumen Maity contributed startup diagnostics and connector clarity; Ayush Kumar developed major interface and resume-builder features; Shyam Kumar built resume-template and PDF-preview improvements. Claude and Codex assisted with implementation, debugging, and writing; the team remains responsible for the claims and code.
If you are building an agent that acts outside your application, I would be interested in one detail of your design: what happens when the action may have succeeded, but the acknowledgment never arrives?
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article