Founding Go Developer - AI SaaS Platform
Role details
Job location
Tech stack
Job description
We are building a closed-loop operating system for automotive repair businesses. The platform will connect:
- Shop management.
- Estimates.
- Repair orders.
- Invoices.
- Customer and vehicle history.
- Accounts payable.
- Credit card transactions.
- Bank transactions.
- Document reconciliation.
- Accounting workflows.
- Payroll logic.
- Technician pay.
- Owner dashboards. AI-assisted workflow automation., * Python for AI, OCR, document processing, and automation where appropriate.
- React for frontend interfaces.
- PostgreSQL for relational data.
- APIs for banking, credit card, payroll, accounting, and shop workflows.
- AI coding agents and LLM-based development tools.
- OCR and document matching. Audit trails and approval workflows.
You do not need to know everything on day one. You do need to learn quickly and care about building systems the right way. Go experience is strongly preferred, but a strong backend developer who can become productive in Go quickly may also be a fit. What You Will Actually Do:
- You will work directly with ownership and technical leadership.
- There are no layers of management.
- There are no committees.
- There are no endless meetings.
- You will help turn real business workflows into working software.
You will:
- Build backend services in Go.
- Design database structures and business logic.
- Build APIs and system workflows.
- Use AI tools to accelerate development.
- Review, test, and improve AI-generated code.
- Build systems for repair orders, invoices, bills, transactions, approvals, and reconciliation.
- Design audit trails so important decisions can be traced later.
- Create and maintain project markdown files, architecture notes, and implementation plans.
- Decide where automation is safe and where human approval is required.
- Help build interfaces that make complex operations understandable.
- Own problems from concept to production.
- Some days you will write code.
- Some days you will review code.
- Some days you will map a workflow on a whiteboard.
- Some days you will document architecture so future AI tools and developers understand the system.
- Some days you will realize the original idea was wrong and help design a better one.
That is normal here. The Personality That Fits Here:
- The right person may be quiet.
- The right person may prefer working deeply instead of talking constantly.
- The right person may enjoy solving complex problems alone before discussing the answer.
- That is completely fine.
We value people who:
- Notice details others miss.
- Think in systems.
- Like understanding how things really work.
- Prefer clear and direct communication.
- Can focus for long periods.
- Are comfortable working independently.
- Care more about accuracy than appearances.
- Are willing to question assumptions.
- Do not need constant meetings to feel productive.
- Like building tools that other people depend on. Are persistent when a problem is difficult.
We are not looking for corporate polish. We are looking for judgment, ownership, and the ability to build. Who May Be a Strong Fit. You may be a strong fit if:
- You are self-taught or learned by building real things.
- You have built applications, tools, systems, automations, apps, or platforms on your own.
- You can point directly to GitHub or working examples of what you have built.
- You enjoy backend systems and business logic.
- You like using AI tools, but you do not blindly trust them.
- You use documentation, notes, markdown files, or architecture files to organize your thinking.
- You can explain why you made a technical decision.
- You are comfortable saying "this does not make sense" when something is wrong.
- You care about edge cases.
- You like clean data models.
- You think audit trails and permissions matter.
- You would rather solve a real problem than chase trends. You want meaningful responsibility early.
We are less interested in credentials than proof that you can think and build. Who Will Probably Not Enjoy This Role: This is probably not the right role if:
- You need a large team around you.
- You need every task fully defined before starting.
- You only want to work from tickets.
- You prefer meetings over building.
- You want a highly structured corporate environment.
- You are uncomfortable making technical decisions.
- You think AI-generated code should be trusted without review.
- You think AI-generated code is always worthless.
- You dislike documenting your work.
- You are mainly looking for remote work.
- You are applying to hundreds of jobs with the same generic response. You cannot show examples of applications, systems, or tools you have built.
- Location:
- This is a strictly in-office position.
- No remote.
- No hybrid.
- We need someone close to the business, the workflows, the CTO, and the real problems we are solving.
- If you are not able to work in office, this role is not a fit., * Your GitHub profile or links to applications, tools, APIs, automations, or systems you have built.
- A short explanation of the most important thing you personally built or owned.
- What problem it solved.
- Why you approached it the way you did.
- What technical decisions you made.
- What tradeoffs you accepted.
- What broke, failed, or became harder than expected.
- What you would do differently today.
- Your experience with Go/Golang.
- What AI coding tools you use.
- How you verify AI-generated code before trusting it.
- How you use markdown, documentation, architecture files, or technical notes to organize a project.
- One example of a time you disagreed with the original product or technical direction and what you did about it.
Include anything that proves you can build:
- GitHub repositories.
- Live demos.
- Screenshots.
- Documentation.
- Architecture diagrams.
- Personal projects.
- Internal tools.
- Automation scripts. Workflows you designed.
If you built something useful that other people never fully understood or appreciated, start there. We are not looking for the best interviewer. We are looking for the right builder. About European Service Center
Requirements
Do you have experience in Workflow management (operations management method)?
Benefits & conditions
Pulled from the full job description
- Paid training
- Health insurance
- 401(k) matching
- Vision insurance
- Dental insurance
- Paid holidays, * The goal is to build a business operating platform where every workflow connects to the next one.
- A repair order should connect to an invoice.
- An invoice should connect to accounting.
- A vendor bill should connect to a payment.
- A credit card charge should connect to a document.
- A payroll decision should connect to the work actually performed.
- Every important action should be traceable.
- Every exception should be reviewable.
- Every workflow should make the system smarter over time.
The Kind of Person We Are Looking For: We are looking for a builder. Not just someone who writes code from tickets. Not just someone who waits for detailed instructions. Not just someone who knows how to talk about software. We need someone who can look at a messy real-world business problem and ask:
- What is really happening here?
- What data needs to be captured?
- What should the system decide automatically?
- What should a human approve?
- What can go wrong?
- How do we make this reliable? How do we prove what happened later?
This role requires judgment:
- AI tools will be used heavily, but AI does not replace judgment.
- AI can generate code quickly.
- The hard part is knowing whether the code is right.
Freedom To Build With AI:
- We believe modern software development has changed.
- We do not want someone who is afraid of AI tools.
- We want someone who knows how to use them responsibly.
- You will have significant freedom to use AI coding agents, LLMs, automation tools, and whatever development workflow helps you move faster.
- We care about results, architecture, documentation, and maintainability.
- We do not care whether every line of code was typed manually.
Our expectations are simple:
- Use AI aggressively.
- Verify the output.
- Keep the architecture clean.
- Document important decisions.
- Use markdown files extensively to preserve project knowledge.
- Maintain clear technical notes, architecture files, and implementation plans.
- Follow good engineering practices.
- Test what matters.
- Do not blindly trust generated code. Leave the system better organized than you found it.
If you already use AI tools to build faster, think better, and document your work more clearly, that is a major plus. Core Technology:
- Our backend heavily leans on Go/Golang.
- We use Go because we want backend services that are reliable, readable, fast, and maintainable., * Base salary starts at $85,000, with meaningful equity included.
- We are an early-stage startup, so we want to be direct.
- This is not a big-company compensation package.
- The upside is in joining early, taking real responsibility, and helping build a valuable company.
Benefits include:
- Health insurance.
- Dental insurance.
- Vision insurance.
- 401(k) with company match.
- Paid vacation. Paid holidays.