Oluwatosin Kazeem

The challenge. Modern job searching has become fragmented. Candidates move between job boards, AI tools, ATS checkers, spreadsheets, and interview resources, repeatedly recreating the same professional story from scratch.

The solution. Pamoja unifies the entire workflow into a single platform powered by a persistent professional Memory, letting users generate authentic, tailored application materials while staying in control of every important decision.

When I moved to the Netherlands for my Master’s in Digital Design, finding a job was not an ambition, it was an immediate necessity. Back home in Nigeria I was earning nowhere near enough to sustain a student in Amsterdam. So I did what most job seekers do: opened LinkedIn every morning, searched for product design roles, tailored a resume, wrote a cover letter, and applied. With more than six years of experience and a solid portfolio, I believed interviews would come.

They never did. For weeks, and then months, I applied to role after role without a single invitation. At first I questioned my ability, my portfolio, my experience, even whether companies simply would not sponsor a visa. The more I spoke with recruiters, the more I realised the problem was more complex than “not good enough.”

One conversation changed everything. At a recruitment event, recruiters explained that most modern hiring begins long before a human reads an application. Resumes are first processed by Applicant Tracking Systems (ATS) that evaluate them against a job description. Even highly qualified candidates could be rejected before anyone saw their work, simply because their resume did not communicate the right information in the right way. I had to survive that first interview with software before I ever reached a person.

So I changed my process. For every job I copied the description into ChatGPT, asked it to rewrite my resume, generated a cover letter, corrected the output, downloaded the files, and applied. The quality improved, but every application took fifteen to twenty minutes, and every conversation started from scratch, forcing me to re-explain who I was.

The deeper problem was memory. The quality of each application depended almost entirely on what I happened to remember that day. Sometimes I recalled a strong project or a metric; other times I forgot experiences that would have made the application far stronger. The issue was not a lack of experience, it was that I could not consistently present the best version of it. That realisation became the foundation of Pamoja: people should be evaluated on everything they have accomplished, not on what they happen to remember when they sit down to apply.

My experience was frustrating, but far from unique. Classmates, recruiters, and highly skilled designers, developers, and product managers were all sending dozens, sometimes hundreds, of applications with little response. That made me question whether the problem was really talent, or whether something larger had changed in hiring itself.

As companies receive thousands of applications per role, ATS filtering has become essential for employers, and has fundamentally changed how candidates must apply. A resume is no longer a summary of a career; it is a document that must communicate relevant experience in a way both software and humans understand. Capable candidates are filtered out long before a meaningful evaluation takes place.

The market responded with resume builders, ATS checkers, cover letter generators, and job tools, each solving a small part of the problem. Candidates were expected to move constantly between platforms, and even AI reset to a blank slate every time, beginning each conversation with “Tell me about yourself.” Every application depended not only on experience, but on what the user happened to remember in that session.

The clearer the behaviour became, the clearer the real problem became. Job seekers were not struggling because they lacked ability. They were struggling because they had no reliable system for organising, remembering, and presenting their experience consistently.

When generative AI arrived, dozens of products promised to write resumes, optimise ATS scores, and even apply automatically. After using them extensively, I realised they solved only the visible part of the problem.

The first issue was context: every conversation started blank, and context windows eventually filled up, so I created new chats just to maintain quality. The second was fragmentation: no single product managed the whole journey. The third was memory: AI could only work with what I remembered to provide, so my strongest achievements, often the easiest to forget, were regularly left out.

I also noticed a trend toward complete automation, with products applying to hundreds of jobs on a user’s behalf. I deliberately chose not to build Pamoja that way. Recruiters are already overwhelmed by automated applications, and removing people from the decision would only worsen that while stripping users of control. AI should help people move faster, never remove them from decisions that carry their name.

Two technical realities shaped the product further. Early versions used AI to calculate ATS scores, but the same resume could score very differently on repeated runs, destroying trust. And during testing the model occasionally invented achievements users had never accomplished. Both problems pointed to the same conclusion.

I redesigned scoring to be deterministic, and constrained generation so AI could only work with information already in the user’s resume and Memory. Instead of inventing experiences, the system reorganises, refines, and highlights authentic ones.

Building Pamoja did not begin with wireframes. It began with a question: “Am I the only person experiencing this?” Rather than assume, I spoke with the people around me, observed their behaviour, and compared it with my own.

I started with classmates at the Amsterdam University of Applied Sciences, many of whom had relocated from around the world and were job hunting in the Netherlands. Despite different backgrounds, a common pattern emerged: everyone had cobbled together their own fragmented workflow from AI tools, resume builders, ATS checkers, and spreadsheets.

At career fairs and recruitment events I heard the other side of the table. Recruiters reviewing hundreds of applications relied on ATS to manage the volume, and were not looking for perfect resumes, but for evidence that a candidate had the required experience, communicated clearly and aligned to the role.

Almost everyone applied reactively, reconstructing each application from old resumes, portfolios, and notes. Valuable achievements were forgotten under pressure. The competitive landscape confirmed it: resume builders, cover letter generators, ATS checkers, and job boards each solved one problem well, but none understood the entire journey. Research did not just validate the idea, it redefined it, shifting the focus from document generation to professional memory.

Every product reaches a point where the problem becomes clearer than the solution. Looking back at my own applications, every resume was slightly different, not because my experience had changed, but because my memory had. My professional history was constant, yet every application told a different story because I relied on what I could recall in that moment.

Professionals accumulate projects, achievements, presentations, certifications, and stories over years, and forget most of them under pressure. Existing AI tools reinforced the problem by beginning every session with “Tell me about yourself.” AI had become a better writer, but it still had a poor memory. That insight became the core of Pamoja: Memory.

Unlike a resume rewritten under pressure, Memory grows over time. Every project, promotion, or certification can be added as it happens, shifting the mindset from remembering a career only when you need a job to continuously documenting it as you grow. By the time an opportunity appears, the platform already understands who you are.

Memory transformed every other feature. Resume optimisation, cover letters, and interview preparation all draw from an evolving understanding of the person, and AI is constrained to reorganise and prioritise what exists rather than invent it. Memory is not one feature inside Pamoja, it is the foundation the rest is built on.

With Memory as the foundation, the next challenge was translating it into a product that felt effortless. Pamoja was sourcing jobs, managing a knowledge base, optimising materials, tracking applications, and preparing users for interviews, all without overwhelming them. One principle guided every decision: reduce effort, not control.

One of the biggest challenges had little to do with interface design. It was trust. As I experimented with models, I realised the experience depended less on how intelligent AI appeared and more on whether users could consistently rely on its outputs. So I stopped asking “How can AI do more?” and started asking “How can users trust AI more?”

Not every problem should be solved by AI simply because AI is available. ATS scoring is fundamentally a rules-based problem, so I rebuilt it as a deterministic engine that returns the same result every time the same inputs are analysed. AI still improves resumes; the scoring itself became predictable.

I also constrained generation to a knowledge base of only the user’s resume and Memory. AI may reorganise, rewrite, and prioritise, but never invent, which dramatically reduced hallucinations and kept users accountable for every application. And rather than presenting a finished document to trust blindly, the optimisation results page explains exactly what happened: the ATS analysis, the keywords added, and every significant change.

Trust also shaped model selection: lightweight models handle extraction where consistency matters, while capable models handle optimisation and writing where reasoning matters. That balanced cost with quality and kept the platform affordable for people who are actively job searching.

One of the earliest decisions had nothing to do with technology. It was about responsibility. As products raced to automate the entire application process, I believed they were solving the wrong problem. The purpose of Pamoja was never to remove people from hiring, it was to remove repetitive work.

Applying for a job is a personal decision. Several early users asked for automatic applications, and the request was understandable, but I chose not to build it: speed should never come at the expense of accountability. Users should always know where they are applying and what is being submitted.

The final flow reflects this. Instead of an automatic submission, Pamoja presents an “Apply on Site” action: it opens the employer’s page, downloads the optimised resume, and copies the cover letter to the clipboard, ready to paste. AI accelerates preparation while the user remains in control of submission, always asking a single question of every feature: is the AI making the user more capable, or simply making decisions for them?

The feature most people associate with Pamoja is resume optimisation. Rewriting resumes was never the hard part; keeping the result authentic, relevant, and representative of the person’s real experience was. The goal was not another resume generator, but a system that helps people communicate their experience more effectively without changing who they are.

It begins with a pasted job URL. The platform extracts the responsibilities, skills, and expectations into a structured format, then combines three sources: the resume, the job requirements, and the knowledge stored in Memory. Instead of treating the resume as the only source of truth, it can surface relevant achievements and stories that were never in the document, strengthening the application without inventing anything.

Two invisible engineering decisions mattered most. Scoring became deterministic so identical inputs always score the same. And job extraction was made consistent, an early version summarised postings before optimisation, which introduced score variance; fixing it kept differences within a small margin. Neither was visible in the interface, but both strengthened trust. Throughout, the platform balanced ATS keyword matching with readability, because recruiters still make the final decision.

For many job seekers, cover letters feel even harder than resumes. They ask candidates to explain why they want a role and how their experience connects to it, a level of reflection and storytelling that is difficult to sustain across dozens of applications. My own process, copying a job description into ChatGPT, produced letters that felt generic and repeated the resume.

Pamoja already possessed what those tools lacked: Memory. The system analyses the role, identifies the qualities the employer values most, and searches Memory for experiences that demonstrate them. If a company emphasises stakeholder management, it prioritises stories of collaboration and influence; if the role is about product thinking, it surfaces projects that improved metrics or shaped direction. Every paragraph is grounded in a genuine experience rather than a generic statement.

Authenticity was the guiding principle: every sentence must be traceable to something the user actually did. AI improves the writing and connects experiences to the role, but never fabricates. And because the product also makes the letter easy to review and edit, users stay in control, while the output naturally improves as their Memory grows.

Finding opportunities is as time-consuming as applying for them. Even with excellent resumes and cover letters, users would still spend hours browsing job boards. Job Scout continuously searches for opportunities that match a user’s preferences, making discovery part of the product rather than an external task.

Setup takes minimal effort: users specify roles, locations, and seniority once, and the platform surfaces relevant matches. The hardest design question was how much to show on each job card. Early concepts showed only a title and company, forcing users to open each one; through iteration, each card grew to show company, role, location, employment type, and, most importantly, a match percentage. That score turned Job Scout from a feed into a decision-support tool, letting users focus where they are most likely to succeed, and flow straight into optimisation without leaving the platform.

Resumes and cover letters solve only one part of the journey, they help candidates secure an interview. A perfectly tailored resume means little if the candidate then struggles to communicate their experience in conversation. Stopping at application materials would leave the product incomplete, which became the motivation behind Interview Preparation.

Most interview tools generate generic questions by profession. Because Pamoja already understands the job description, the optimised resume, and the user’s Memory, it can do something different: prepare users with scenarios tailored to the specific role, grounding suggested answers in their own achievements and stories. The interview becomes a continuation of the application rather than a separate exercise.

This required conversation design rather than static output. Instead of a list of questions, the goal is a simulated interview that asks follow-up questions, evaluates responses, and gives feedback based on the role and the user’s history, so people practise explaining their real experiences rather than memorising answers. The feature is still under active development, and the problem space is large enough that it could become a product in its own right, so the first version stays deliberately focused.

As the sole designer and engineer, I built what I designed. Every component I designed, I had to implement, and every technical constraint I hit, I had to design around. That feedback loop made both the design and the code better, and it removed the usual waste between the two disciplines.

I began this project as a designer, focused on flows and interfaces. As it progressed, I found myself thinking about operating costs, AI infrastructure, pricing, and long-term sustainability. Somewhere in there I stopped thinking only as a designer and started thinking like a founder.

The first lesson came from AI itself. Using the most capable model for every task was financially unsustainable, so I designed a layered pipeline: lightweight models for parsing resumes into structured data, capable models for generating from Memory. Pricing was the second lesson. Most AI products charge monthly, but job searching is episodic, and users are often financially stressed, so I chose a credit-based model where people pay only for the work they consume.

Building the product also changed how I measured success. Feature count means little if features do not solve meaningful problems, so I began asking whether each one genuinely reduced effort, helped users get interviews faster, or strengthened trust. Those questions often led me to simplify rather than expand, and to say no to ideas, like automatic applications, that conflicted with the long-term vision even when they looked commercially attractive.

I never wanted Pamoja to be built on assumptions alone. The first version was intentionally small, focused on generating tailored resumes and cover letters, and I gradually introduced Memory, Job Scout, Application Tracking, and the early foundations of Interview Preparation, validating each independently.

The earliest lesson came from language. The feature I called AI Auto-pilot led users to assume the platform applied on their behalf; renaming it Job Scout immediately clarified its purpose. Another came from transparency: some users expected AI to behave like magic, so I redesigned parts of the experience to explain where information came from and why recommendations appeared. Confidence rose sharply once people understood the reasoning behind an output.

The most rewarding surprise was Memory. I had treated it as infrastructure, but users treated it as valuable in its own right, building their professional knowledge base long before they needed to apply again. That confirmed an early hypothesis: people were not just looking for AI-generated documents, they wanted a better way to organise and communicate their professional lives.

Today the platform is used by roughly fifty active users, and I personally know only about ten of them, a small detail that means a great deal: it marks the shift from designing for people I could observe to people who found and adopted the product on their own. The clearest validation of all is watching users complete in under a minute what once took fifteen or twenty.

I thought I was designing an AI product for job seekers. Looking back, I was really designing a better way of thinking about products. Pamoja challenged almost every assumption I had about design, technology, user behaviour, and business.

Products are rarely built in a straight line. Research changed the direction, user feedback changed the interface, AI limitations changed the architecture, and business decisions changed priorities, each stage continuously influencing the others. Assumptions proved expensive: I assumed users would immediately understand the product, yet many believed it applied to jobs automatically. The responsibility was mine, and small changes, renaming features, refining onboarding, had more impact than redesigning whole screens.

The most significant lesson involved AI itself. It is powerful, but inconsistent and capable of convincing inaccuracies, so I learned to ask a different question: “Should AI even be responsible for solving this problem?” That led to deterministic scoring, constrained generation, and mandatory human approval. Good AI products are not those that maximise automation, but those that choose carefully where intelligence creates genuine value. And UX, I realised, extends far beyond the screen: pricing, transparency, waiting time, trust, and even the wording of a single button are all part of the experience.

When I think about the future of Pamoja, I don’t think first about new features. I think about a different experience: a career companion that grows alongside a person, understands their journey, and supports them at every milestone. The first version focuses on finding a job, but employment is only one chapter of a much longer professional life.

This is why Memory represents the future of the platform. Today it stores achievements, stories, and skills that improve resumes and cover letters; in time it could become a comprehensive professional knowledge base that captures career growth continuously, so materials are always up to date. Interview Preparation could grow into a product of its own, and Job Scout could evolve from finding opportunities into career intelligence, recommending skills, certifications, or projects that improve competitiveness before someone even begins searching.

Throughout, I remain cautious about how far automation should go. AI should reduce repetitive work and surface better insights, but never replace judgement, and the platform should stay accessible to people navigating one of the most financially uncertain periods of their careers. Success, five years from now, would not be measured only in revenue or users. It would be hearing that Pamoja helped someone secure an opportunity they might otherwise have missed.

When I look back at Pamoja, I don’t just see a product. I see a collection of lessons, experiments, and conversations that shaped both the platform and the person building it. What started as a personal frustration became an opportunity to rethink how people experience one of the most stressful periods of their professional lives.

The best products rarely begin with ambitious technology. They begin with empathy, by paying attention to small frustrations people have quietly accepted as normal. Good design is not measured by how little friction exists inside an interface, but by how much friction disappears from a person’s life because the interface exists. Every feature in Pamoja was designed around that principle, and building it changed how I think: I no longer see design as creating interfaces, but as creating systems that enable better decisions and better outcomes.