Jobs at Specmatic

Specmatic is a pioneer in Contract-Driven Development (CDD) and Executable API Contracts. This modern software development approach emphasises the use of API specifications as actionable, enforceable contracts. It allows development teams to use API specifications not just as static documents but as dynamic, executable contracts that can be automatically tested, verified, and used to simulate service behaviors.

 Here’s an overview of how executable API contracts work and their benefits:

 – Contract as Tests: This aspect automates testing by using API specifications to generate tests dynamically. It ensures that the implementation consistently adheres to the specified API contract, facilitating ongoing compliance with the defined API behavior.

 – Contract as Stub: This allows for the stubbing of services based on their API specifications, offering a mock version of the API that behaves according to the contract. This is particularly useful for testing and development purposes, as it allows client applications to interact with a simulated version of the API.

 – Enhanced Collaboration: By centralizing API specifications in a repository, it becomes easier for teams across an organization to collaborate. A central contract repository acts as the single source of truth for API specifications, streamlining the process of proposing changes, conducting reviews, and ensuring compatibility before integration.

 – Preventing Breaking Changes: Tools like Specmatic can be used to enforce backward compatibility checks as part of the merge process in version control systems. This helps in identifying potential breaking changes early in the development cycle, thereby reducing integration issues and fostering a smoother deployment process.

 – Automation and CI Integration: Executable API contracts integrate well with Continuous Integration (CI) workflows. By automating contract testing and stubbing within CI pipelines, teams can ensure that changes are validated for compliance with the contract before they are merged and deployed.

 Adopting executable API contracts offers several advantages, such as improved API reliability, better collaboration between teams, and a more efficient development process. By treating API specifications as living documents that can be executed, tested, and validated, organizations can move towards a more agile and resilient microservices architecture.

 For more detailed insights into executable API contracts and contract-driven development, you can explore Specmatic website, which outlines how to turn contracts into executable specifications, and discussions on practical adoption journeys and the significance of maintaining a central contract repository.

• Drive features independently with guidance from leadership and other senior team members
• Being an early team member you will also be expected to own certain aspects of the product and be a subject matter expert on the same
• Guide and coach fellow team members and junior devs
• Will be great if you are able to spread the word about the product by speaking at conferences and writing about the same

Just the process of getting on boarded to the project can give you a sea of knowledge in several areas

• Be at the forefront of Contract Driven Development which is quickly becoming an approach of choice for all companies large and small
• Putting large language models to use to revolutionize entire development process
• Software Engineering
• Contemporary and Bleeding Edge Techniques
• API Design (RESTful & Async) and Specifications (OpenAPI, AsyncAPI, etc.)
• Continuous Integration Pipelines and principles
• Test Food Pyramid – Types and purposes of various types of tests
• Extreme Programming Techniques
• Evolutionary Design and Architecture
• Test Driven Development
• Refactoring
• Pair Programming
• CI/CD
• Git Branching Strategies, Pull Request Etiquettes
• Trunk based development
• Programming Languages and Clean Code Practices
• Kotlin, Java, JavaScript, Python, C# (near future)
• SOLID Principles
• Functional Programming

Specmatic is redefining how teams ship reliable, AI-ready APIs faster and transforming how enterprises build, test, and govern their APIs.

Specmatic addresses today’s integration and velocity challenges with a #NoCode, developer-first platform that turns your API specifications into executable contracts which serves as the single source of truth for contract & workflow testing, resiliency & compatibility checks, intelligent mocking, agentic workflow orchestration via MCP server, example validation, documentation, and API governance across all API specification standards and protocols. 

We work with some of the world’s leading technology organisations and digital platforms to help them deliver reliable, AI-ready APIs faster and with confidence. 

 – Contract as Tests: This aspect automates testing by using API specifications to generate tests dynamically. It ensures that the implementation consistently adheres to the specified API contract, facilitating ongoing compliance with the defined API behavior.

 – Contract as Stub: This allows for the stubbing of services based on their API specifications, offering a mock version of the API that behaves according to the contract. This is particularly useful for testing and development purposes, as it allows client applications to interact with a simulated version of the API.

 – Enhanced Collaboration: By centralizing API specifications in a repository, it becomes easier for teams across an organization to collaborate. A central contract repository acts as the single source of truth for API specifications, streamlining the process of proposing changes, conducting reviews, and ensuring compatibility before integration.

 – Preventing Breaking Changes: Tools like Specmatic can be used to enforce backward compatibility checks as part of the merge process in version control systems. This helps in identifying potential breaking changes early in the development cycle, thereby reducing integration issues and fostering a smoother deployment process.

 – Automation and CI Integration: Executable API contracts integrate well with Continuous Integration (CI) workflows. By automating contract testing and stubbing within CI pipelines, teams can ensure that changes are validated for compliance with the contract before they are merged and deployed.

 Adopting executable API contracts offers several advantages, such as improved API reliability, better collaboration between teams, and a more efficient development process. By treating API specifications as living documents that can be executed, tested, and validated, organizations can move towards a more agile and resilient microservices architecture.

 For more detailed insights into executable API contracts and contract-driven development, you can explore Specmatic website, which outlines how to turn contracts into executable specifications, and discussions on practical adoption journeys and the significance of maintaining a central contract repository.

We are seeking a Technical Pre-Sales & Solutions Architect to help accelerate enterprise adoption of Specmatic.  

This role blends technical depth, consultative storytelling, sales acumen, and product evangelism; ideal for someone who thrives at the intersection of engineering excellence and business impact. You’ll articulate how Specmatic solves real-world problems in large-scale, distributed engineering environments and demonstrate that value hands-on through POCs. 

You’ll work directly with CTOs, Heads of Platform, and Engineering Directors to help them understand Specmatic’s value, design tailored solutions, prove technical feasibility, and accelerate customer success. 

• Deep understanding of API specifications and protocols (OpenAPI, AsyncAPI, GraphQL SDL, Proto3, WSDL, JSON Schema, MCP, A2A, etc.). 

• Hands-on experience with API lifecycle management, contract testing, mocking, resiliency testing, governance, versioning, security, performance and observability. 

• Working knowledge of CI/CD pipelines, service virtualisation, and DevOps toolchains. 

• Experience with event-driven architectures and messaging systems (Kafka, Google Pub/Sub, JMS, AMQP, etc.). 

• Solid grounding in  

• Networking  

• Protocols (DNS, TCP/IP, DHCP)  

• OSI Networking Model  

• Networking troubleshooting and diagnostics  

• Microservices Architecture – Service design, Discovery, Circuit breakers, Service Mesh, Traceability, Observability, Self-healing, Resiliency, Zero downtime deployment, feature toggling, etc.  

• Cloud-native platforms (Kubernetes, containers), and modern software engineering practices 

• Shift-left testing  

• Unit testing  

• Contract testing  

• API / Component testing  

• Integration / Workflow testing  

• Service virtualization  

• XP Practices  

• Test Driven Development  

• Clean code practices and Refactoring   

• Pair programming   

• Trunk-based development