{"id":2506,"date":"2026-09-15T04:42:47","date_gmt":"2026-09-15T04:42:47","guid":{"rendered":"https:\/\/getprojects.ai\/blog\/?p=2506"},"modified":"2026-09-15T04:42:47","modified_gmt":"2026-09-15T04:42:47","slug":"questions-to-ask-a-software-development-company","status":"publish","type":"post","link":"https:\/\/getprojects.ai\/blog\/questions-to-ask-a-software-development-company\/","title":{"rendered":"27 Questions to Ask a Software Development Company Before You Hire"},"content":{"rendered":"

Forty-five percent is the average budget overrun on large IT projects, and the ones that collapse almost never collapse during development. They collapse during selection\u00a0 in the 45-minute vendor call where a buyer, working without a structured set of questions to ask a software development company, mistakes a polished pitch deck for delivery capability.<\/span><\/p>\n

The asymmetry is brutal. An agency has run this conversation 400 times; most buyers run it three or four times in a career. The agency knows which questions signal a sophisticated client and which signal someone who will accept “we’ll figure out scope in discovery.” Those two buyers get quoted differently, staffed differently, and treated differently when something slips in month four.<\/span><\/p>\n

McKinsey and the University of Oxford analysed more than 5,400 IT projects and found that large IT projects run <\/span>45% over budget and 7% over time <\/b><\/a>while delivering 56% less value than predicted\u00a0 with 17% overrunning badly enough to threaten the company’s existence. Software projects carried the highest overrun risk of any category.\u00a0<\/span><\/p>\n

What follows is 27 questions grouped into six evaluation blocks: team, process, commercial, technical, security, and exit\u00a0 each with the answer you want and the answer that should make you walk. Print it, hand it to whoever runs the call, and score every response before the next vendor dials in.<\/span><\/p>\n

What Are the Questions to Ask a Software Development Company?<\/b><\/h2>\n

The questions to ask a software development company are a structured set of vendor due diligence prompts covering team composition, delivery process, commercial terms, technical reasoning, security posture, and exit rights\u00a0 designed to surface capability gaps and contractual risk before a statement of work is signed rather than after. They function as<\/span> a practical buyer framework<\/b><\/a> rather than a conversation starter.<\/span><\/p>\n

Good agency screening questions share one property: the answer cannot be rehearsed from a marketing page. “Do you follow Agile?” can. “Show me last sprint’s velocity chart for a client of our size” cannot. That distinction matters more than<\/span> where you source those agencies<\/b><\/a>, because a weak question set fails on a strong shortlist.<\/span><\/p>\n

The Real Cost of Unstructured Software Vendor Interview Questions<\/b><\/h2>\n

Most buyers run three to five vendor calls, take loose notes, and decide on a combination of price and rapport\u00a0 regardless of which of<\/span> the routes buyers actually use<\/b><\/a> brought the vendors to the table. That process has a predictable failure mode: it selects for sales quality, not delivery quality.<\/span><\/p>\n

The financial exposure is concrete. A mid-market build quoted at $60,000\u2013$120,000 typically carries a 30\u201350% change-order tail when scope was never pinned down in<\/span> a written development brief<\/b><\/a>. On a $90,000 engagement, that is $27,000\u2013$45,000 of unplanned spend, usually arriving in months three and four when switching vendors costs more than absorbing the overrun.<\/span><\/p>\n

Timeline damage compounds it. Replacing an agency mid-build costs 6\u201310 weeks: two to three to re-scope, two to four to re-tender, two to three for a new team to read an undocumented codebase\u00a0 before accounting for the contractual friction of<\/span> exiting a software development contract<\/b><\/a>. Teams underestimate that window by 3\u20134x.<\/span><\/p>\n

Then there is the silent cost. An unstructured vendor call leaves three things undecided at signature:<\/span> who owns the code when you outsource<\/b><\/a>, what happens to it if the relationship ends, and which named engineers are actually allocated. Each one becomes a negotiation from a position of zero leverage later. A fixed list of questions to ask a software development company forces all three onto the table while you still have alternatives.<\/span><\/p>\n

The 27 Questions to Ask a Software Development Company, Grouped by Block<\/b><\/h2>\n

Run these in order. Team first, because everything downstream depends on who is actually building. Exit last, because an agency that has relaxed through 23 questions answers the uncomfortable ones more honestly. Score each answer green, amber, or red; two reds in any single block is a disqualification, not a discussion point.<\/span><\/p>\n

Block 1\u00a0 Team: Who Actually Builds This<\/b><\/h3>\n

The single most common substitution in agency work is the pitch team versus the delivery team. Knowing what to ask a dev agency about staffing closes that gap before it opens, which is why the questions to ask a software development company start here rather than with price\u00a0 and why a thin answer here often means the work is really a<\/span> staff augmentation arrangement<\/b><\/a> in disguise.<\/span><\/p>\n

    \n
  1. Who specifically will work on this project, and what percentage of their week is allocated to us?<\/b><\/li>\n<\/ol>\n

    Named individuals, named roles, named allocation\u00a0 “two senior engineers at 100%, QA at 50%, tech lead at 30%.”\u00a0 “We’ll assign the right resources at kickoff.”<\/span><\/p>\n

      \n
    1. Will the people in this meeting write the code?<\/b><\/li>\n<\/ol>\n

      A direct yes, or an honest no with the delivery lead introduced on the next call.\u00a0 Deflection to “our teams are interchangeable.”<\/span><\/p>\n

        \n
      1. What is your engineering attrition rate, and average tenure?<\/b><\/li>\n<\/ol>\n

        A real number\u00a0 12\u201320% annual attrition is normal, average tenure above two years is healthy.\u00a0 “We don’t track that,” or a suspiciously perfect figure.<\/span><\/p>\n

          \n
        1. What happens if our lead engineer leaves in month three?<\/b><\/li>\n<\/ol>\n

          A shadowing policy, an overlap period, and a named backup already reading the codebase.\u00a0 “That won’t happen.”<\/span><\/p>\n

            \n
          1. Who is my single point of accountability, and what can they decide without escalating?<\/b><\/li>\n<\/ol>\n

            One name, with authority over scope, staffing, and schedule inside agreed limits.\u00a0 Three contacts and no clarity on who owns a missed deadline.<\/span><\/p>\n

            Block 2\u00a0 Process: How the Work Actually Moves<\/b><\/h3>\n

            Process questions are only worth asking if the answers end up somewhere enforceable, which in practice means<\/span> acceptance criteria written into the contract<\/span><\/a> rather than described on a call.<\/span><\/p>\n

              \n
            1. Walk me through your first 30 days on a project this size.<\/b><\/li>\n<\/ol>\n

              A <\/span>technical discovery<\/b> sequence with named deliverables\u00a0 architecture doc, backlog, risk register, environments.\u00a0 “We start coding in week one.”<\/span><\/p>\n

                \n
              1. What does a sprint look like, and what do I see at the end of each one?<\/b><\/li>\n<\/ol>\n

                A fixed <\/span>sprint cadence<\/b> with working software in a staging environment, not a status slide.\u00a0 Demos described as “progress updates.”<\/span><\/p>\n

                  \n
                1. How do you handle scope changes mid-project?<\/b><\/li>\n<\/ol>\n

                  A written change-request process with cost and schedule impact quoted before work starts.\u00a0 “We’re flexible” with no mechanism attached.<\/span><\/p>\n

                    \n
                  1. What is your QA process, and who owns testing?<\/b><\/li>\n<\/ol>\n

                    Dedicated QA headcount, test coverage targets, and a bug-severity triage policy.\u00a0 Developers testing their own work, with QA folded invisibly into the rate.<\/span><\/p>\n

                      \n
                    1. How do you tell a client something has gone wrong?<\/b><\/li>\n<\/ol>\n

                      A named escalation path and a real example of bad news delivered early.\u00a0 An answer about positivity and partnership.<\/span><\/p>\n

                      Block 3\u00a0 Commercial: Where the Money Actually Goes<\/b><\/h3>\n

                      Pricing is where the questions to ask a software development company stop being polite. Push until every line item has a number attached to it, and benchmark the total against<\/span> what a build of this size actually costs<\/b><\/a>.<\/span><\/p>\n

                        \n
                      1. Fixed price, time and materials, or dedicated team\u00a0 and why that model for our project?<\/b><\/li>\n<\/ol>\n

                        A reasoned recommendation tied to how well-defined the requirements are. The <\/span>fixed-price vs time and materials<\/b> choice should follow scope clarity, not agency preference.\u00a0 One model offered with no rationale.<\/span><\/p>\n

                          \n
                        1. What is explicitly excluded from this quote?<\/b><\/li>\n<\/ol>\n

                          A written exclusions list\u00a0 licences, app store fees, content, data migration, post-launch support.\u00a0 “Everything’s included.”<\/span><\/p>\n

                            \n
                          1. How do you charge for project management, DevOps, and QA?<\/b><\/li>\n<\/ol>\n

                            Line-itemised, typically 15\u201325% of total for PM and DevOps combined.\u00a0 Bundled into a blended rate you cannot audit.<\/span><\/p>\n

                              \n
                            1. What are the payment milestones, and what happens when one slips?<\/b><\/li>\n<\/ol>\n

                              Deliverable-linked milestones with a defined remedy, a credit, a free sprint, or a payment hold.\u00a0 Calendar-based invoicing detached from output.<\/span><\/p>\n

                                \n
                              1. What is your rate card by role and seniority, and how long is it locked?<\/b><\/li>\n<\/ol>\n

                                Published rates by role with a 12-month lock and a capped annual escalation.\u00a0 A single blended rate with no seniority breakdown.<\/span><\/p>\n

                                Block 4\u00a0 Technical: Whether the Reasoning Holds<\/b><\/h3>\n

                                You are not testing whether the answers are correct, you are testing whether the reasoning is visible. The<\/span> same vetting logic used on app builds<\/b><\/a> applies to any stack.<\/span><\/p>\n

                                  \n
                                1. Why this stack for our problem, and what would you choose at half the budget?<\/b><\/li>\n<\/ol>\n

                                  Trade-offs articulated in terms of hiring market, maintenance cost, and time to first release.\u00a0 The stack the agency always uses, justified by popularity.<\/span><\/p>\n

                                    \n
                                  1. What in our requirements do you think is a bad idea?<\/b><\/li>\n<\/ol>\n

                                    At least one specific, well-argued objection. This is the highest-signal question on the list.\u00a0 Total agreement with everything you have proposed.<\/span><\/p>\n

                                      \n
                                    1. How do you manage technical debt, and what will this codebase look like in 18 months?<\/b><\/li>\n<\/ol>\n

                                      A stated debt budget per sprint (commonly 10\u201320% of capacity) and refactoring treated as scheduled work.\u00a0 “We write clean code.”<\/span><\/p>\n

                                        \n
                                      1. What is your code review and documentation standard?<\/b><\/li>\n<\/ol>\n

                                        Mandatory peer review, a branching strategy, and documentation treated as a deliverable.\u00a0 Documentation quoted as an optional add-on.<\/span><\/p>\n

                                        Block 5\u00a0 Security and Compliance: What You Inherit<\/b><\/h3>\n

                                        You inherit your vendor’s security posture the moment they clone your repository. These four questions to ask a software development company are non-negotiable in regulated sectors, and carry the most weight on<\/span> HIPAA-regulated healthcare builds<\/b><\/a> and financial systems.<\/span><\/p>\n

                                          \n
                                        1. Where will our code and data physically reside?<\/b><\/li>\n<\/ol>\n

                                          Named cloud regions and repositories, plus a clear answer on work done from personal devices.\u00a0 Vagueness about an <\/span>offshore development team<\/b> you were not told about.<\/span><\/p>\n

                                            \n
                                          1. Do you use subcontractors, and how are they vetted?<\/b><\/li>\n<\/ol>\n

                                            Disclosed upfront with the same NDA, security, and background-check standard applied downstream.\u00a0 Discovering a third party through a committed history.<\/span><\/p>\n

                                              \n
                                            1. What certifications do you hold, and when were you last audited?<\/b><\/li>\n<\/ol>\n

                                              ISO 27001 or SOC 2 Type II with an audit date inside the last 12 months, plus GDPR or HIPAA posture where relevant.\u00a0 Compliance described as “aligned with” a standard.<\/span><\/p>\n

                                                \n
                                              1. What is your policy on AI coding assistants and third-party libraries in our repository?<\/b><\/li>\n<\/ol>\n

                                                A written policy covering licence scanning, generated-code review, and repository prohibitions.\u00a0 No policy, or surprise at the question.<\/span><\/p>\n

                                                Block 6\u00a0 Exit and Ownership: What to Ask Before Signing a Software Development Contract<\/b><\/h3>\n

                                                This block is the one buyers skip and the one that costs the most. The questions before signing dev contract terms are settled should be asked while the agency still wants the deal, and the answers belong in<\/span> the master services agreement<\/b><\/a> rather than an email.<\/span><\/p>\n

                                                  \n
                                                1. Who owns the IP, and at what point does ownership transfer?<\/b><\/li>\n<\/ol>\n

                                                  Full assignment to you on payment, with the <\/span>IP ownership clause<\/b> written into the master agreement, not the proposal.\u00a0 Transfer on final payment only, or a licence rather than assignment.<\/span><\/p>\n

                                                    \n
                                                  1. What exactly is in a handover package?<\/b><\/li>\n<\/ol>\n

                                                    Repository access, infrastructure credentials, architecture documentation, deployment runbook, and a <\/span>code handover<\/b> session\u00a0 specified in the <\/span>statement of work<\/b>.\u00a0 “We’ll sort that out if it comes to it.”<\/span><\/p>\n

                                                      \n
                                                    1. What is the notice period, and what are the termination-for-convenience terms?<\/b><\/li>\n<\/ol>\n

                                                      30 days either way, pro-rated fees, and no penalty beyond work completed.\u00a0 90-day notice, or termination fees tied to the full contract value.<\/span><\/p>\n

                                                        \n
                                                      1. Can I speak to a client who stopped working with you?<\/b><\/li>\n<\/ol>\n

                                                        A real referral, offered without defensiveness. Every agency churns clients; only confident ones introduce you.\u00a0 Hand-picked references from active accounts only.<\/span><\/p>\n

                                                        How to Interview an Agency in Five Stages<\/b><\/h2>\n

                                                        Structure beats intuition. Sequence the questions to ask a software development company the same way for every shortlisted vendor so the comparison is genuine\u00a0 whether you are hiring one team or<\/span> outsourcing the build entirely<\/b><\/a>:<\/span><\/p>\n

                                                          \n
                                                        1. Screen on paper (30 minutes).<\/b> Verify the website domain age, check that team profiles exist outside the agency site, and confirm the company is registered where it claims to be.<\/span><\/li>\n
                                                        2. Run the team and process blocks (45 minutes).<\/b> Questions 1\u201310. Two failures here ends the conversation.<\/span><\/li>\n
                                                        3. Request a scoped proposal (5\u20137 days).<\/b> Ask for exclusions in writing. Compare proposals on what they leave out, not what they include.<\/span><\/li>\n
                                                        4. Run the commercial, technical, security, and exit blocks (60 minutes).<\/b> Questions 11\u201327, with the delivery lead present, not only the sales contact.<\/span><\/li>\n
                                                        5. Take two references, including one churned client.<\/b> Ask each the same three questions: what slipped, how was it communicated, and would you rehire.<\/span><\/li>\n<\/ol>\n

                                                          Total elapsed time: <\/span>two to three weeks<\/b>\u00a0 against a 6\u201310 week recovery from a failed vendor choice, the highest-return time you will spend.<\/span><\/p>\n

                                                          What This Looks Like in Practice<\/b><\/h2>\n

                                                          Two engagements show what the questions to ask a software development company are worth in practice.<\/span><\/p>\n

                                                          A Series A fintech, three weeks of screening.<\/b> The team shortlisted four vendors with<\/span> regulated fintech work<\/b><\/a> in their portfolios and ran the full question set. Two could not name allocated engineers (Question 1); one had no IP assignment clause in its template agreement (Question 24). The fourth disclosed its subcontracting arrangement unprompted. That build shipped in 19 weeks against a 22-week estimate, with change orders at 8% rather than the 30\u201350% budgeted.<\/span><\/p>\n

                                                          A retail group that skipped Block 6.<\/b> A $140,000 platform rebuild shipped fine, but the contract granted a perpetual licence rather than IP assignment; the group never established that it would<\/span> own its code completely<\/b><\/a>. Migrating to an in-house team cost a $22,000 buyout plus four weeks of legal work, which Question 24 would have eliminated.<\/span><\/p>\n

                                                          Comparison Framework: Where You Source the Shortlist Changes the Answers<\/b><\/h2>\n

                                                          The sourcing channel determines how much you can verify before the first call\u00a0 and how much of your budget reaches the engineers.<\/span><\/p>\n\n\n\n\n\n\n\n\n
                                                          Sourcing channel<\/b><\/td>\nVerified before contact<\/b><\/td>\nCost to the buyer<\/b><\/td>\nPrimary risk<\/b><\/td>\n<\/tr>\n
                                                          Personal referral<\/span><\/td>\nHigh (one data point)<\/span><\/td>\nNone<\/span><\/td>\nSample size of one; no benchmark<\/span><\/td>\n<\/tr>\n
                                                          Bidding marketplace<\/span><\/td>\nLow<\/span><\/td>\n10\u201320% commission on project value<\/span><\/td>\nPrice-led race to the bottom; commission inflates quotes<\/span><\/td>\n<\/tr>\n
                                                          Paid listing directory<\/span><\/td>\nLow\u00a0 placement is purchased<\/span><\/td>\n$499+\/year borne by agencies<\/span><\/td>\nRanking reflects ad spend, not delivery record<\/span><\/td>\n<\/tr>\n
                                                          Commission-free marketplace<\/span><\/td>\nMedium\u2013high (domain, reviews, team verification)<\/span><\/td>\nNone<\/span><\/td>\nRequires you to still run the interview<\/span><\/td>\n<\/tr>\n
                                                          Open RFP<\/span><\/td>\nNone until submission<\/span><\/td>\nInternal cost: 40\u201380 staff hours<\/span><\/td>\nAttracts volume, not fit<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

                                                          The distinction matters commercially: on bidding platforms, a 15% commission does not come out of agency margin, it is priced into your quote. Commission-free models such as GetProjects remove that layer, but no channel replaces the interview. Verification narrows the field; the questions to ask a software development company decide it.<\/span><\/p>\n

                                                          What Most Teams Get Wrong<\/b><\/h2>\n

                                                          They optimise for price comparability instead of scope comparability.<\/b> Quotes of $70,000, $95,000, and $160,000 are not three prices for one thing; they are three readings of an ambiguous brief. The cheapest usually excludes QA, DevOps, and post-launch support; the dearest includes them and looks expensive. Normalise scope first, then compare.<\/span><\/p>\n

                                                          They treat agreement as competence.<\/b> The agency that says yes to every requirement is the one that will bill every change order. An experienced <\/span>software development partner<\/b> will push back on at least one thing in the first hour\u00a0 and that pushback is worth more than a 10% discount.<\/span><\/p>\n

                                                          They negotiate rates and ignore allocation.<\/b> Dropping a blended rate from $55 to $48 per hour saves 13%, and the<\/span> rate differences between India, Eastern Europe and LatAm<\/b><\/a> are larger still. Getting a senior engineer at 100% allocation instead of 40% changes delivery velocity by 2\u20133x. Buyers spend the whole negotiation on the first number.<\/span><\/p>\n

                                                          They leave exit terms to the lawyers.<\/b> By the time a <\/span>service level agreement<\/b> and IP clause reach legal review, the commercial decision is already emotionally made. Ask Block 6 on the second call, not the seventh.<\/span><\/p>\n

                                                          They interview one agency at a time.<\/b> Sequential interviews destroy comparability\u00a0 by vendor three, you have unconsciously recalibrated your standards to whatever vendor one said. Asking the same questions to ask a software development company in the same order, inside the same fortnight, is what makes the scores mean anything.<\/span><\/p>\n

                                                          Before You Book the First Call<\/b><\/h2>\n

                                                          Take this list into the room. A software development company interview checklist only works if it is used identically across every vendor, so run the same questions to ask a software development company with each one\u00a0 the value is in the comparison, not the individual answer.<\/span><\/p>\n

                                                          If you are assembling a shortlist now and want to interview verified agencies without paying a 10\u201320% commission or entering a bidding war,<\/span> GetProjects<\/b><\/a> connects businesses directly with vetted IT companies across 50+ cities. Posting a project takes under two minutes, costs nothing, and you pay only the agency you hire.<\/span><\/p>\n

                                                          FAQ<\/b><\/h2>\n

                                                          What should I ask a software development company before hiring?\u00a0<\/b><\/h3>\n

                                                          Cover six areas: named team allocation, delivery process and sprint output, commercial exclusions and rate structure, technical reasoning behind the stack, security and subcontracting disclosure, and IP ownership plus handover terms. The 27 questions to ask a software development company above map to those blocks and take about two hours across two calls.<\/span><\/p>\n

                                                          What are the red flags when hiring a development agency?\u00a0<\/b><\/h3>\n

                                                          The four most reliable: refusing to name the engineers assigned to your project, agreeing with every requirement without a single objection, quoting a blended rate with no role-level breakdown, and having no written IP assignment or handover clause. Any two of these together predict change-order disputes with uncomfortable accuracy.<\/span><\/p>\n

                                                          Who owns the code when you hire a development agency?\u00a0<\/b><\/h3>\n

                                                          It depends on the contract, which is why it belongs in the interview rather than legal review. Default agency templates often grant a licence to use the software while the agency retains ownership of reusable components. Insist on full IP assignment on payment, written into the master services agreement.<\/span><\/p>\n

                                                          How do I vet a software development agency without technical staff?\u00a0<\/b><\/h3>\n

                                                          Ask for reasoning, not jargon. Question 16\u00a0 why this stack, and what would you choose at half the budget\u00a0 is answerable without technical knowledge because you are assessing whether trade-offs are explained clearly. Then bring in a fractional CTO for two hours to review the two shortlisted proposals.<\/span><\/p>\n

                                                          Should I hire a freelancer or a software development company?\u00a0<\/b><\/h3>\n

                                                          Under roughly 200 hours of scoped, single-discipline work, a freelancer is usually cheaper and faster. Above that, or where QA, DevOps, design, and project management are all needed, an agency’s cost premium is offset by continuity; freelancer unavailability stops a project entirely, whereas an agency carries a documented backup.<\/span><\/p>\n

                                                          How many agencies should I interview before deciding?\u00a0<\/b><\/h3>\n

                                                          Three to five. Below three, you have no benchmark for what a normal answer looks like. Above five, evaluation fatigue sets in and later vendors get scored against memory rather than notes. Score every agency on the same sheet, in the same order, inside a two-week window\u00a0 and start from a pre-verified shortlist if you can.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                                          Forty-five percent is the average budget overrun on large IT projects, and the ones that collapse almost never collapse during development. They collapse during selection\u00a0 in the 45-minute vendor call where a buyer, working without a structured set of questions to ask a software development company, mistakes a polished pitch deck for delivery capability. The […]<\/p>\n","protected":false},"author":1,"featured_media":2507,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[11],"tags":[],"class_list":["post-2506","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-get-projects"],"_links":{"self":[{"href":"https:\/\/getprojects.ai\/blog\/wp-json\/wp\/v2\/posts\/2506","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/getprojects.ai\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/getprojects.ai\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/getprojects.ai\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/getprojects.ai\/blog\/wp-json\/wp\/v2\/comments?post=2506"}],"version-history":[{"count":1,"href":"https:\/\/getprojects.ai\/blog\/wp-json\/wp\/v2\/posts\/2506\/revisions"}],"predecessor-version":[{"id":2508,"href":"https:\/\/getprojects.ai\/blog\/wp-json\/wp\/v2\/posts\/2506\/revisions\/2508"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/getprojects.ai\/blog\/wp-json\/wp\/v2\/media\/2507"}],"wp:attachment":[{"href":"https:\/\/getprojects.ai\/blog\/wp-json\/wp\/v2\/media?parent=2506"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/getprojects.ai\/blog\/wp-json\/wp\/v2\/categories?post=2506"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/getprojects.ai\/blog\/wp-json\/wp\/v2\/tags?post=2506"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}