The posting
TL;DR
Join GlassDollar and help build the system some of Europe's largest companies use to find, test, and adopt startup technology. We're looking for an engineer who wants considerably more responsibility than "implement what's in the ticket". You'll take an ambiguous problem, shape it together with product, make the important technical decisions, ship it, and stay close enough to see whether it worked. We expect you to have opinions. We also expect you to be good enough to change them.
The problem we're solving
Large organisations are remarkably good at accumulating problems. A company with 100,000 employees can have thousands of operational challenges across its business units. Somewhere outside that organisation, a startup has probably already built part of the solution. Getting those two things to meet still happens through spreadsheets, long email threads, and meetings whose primary output is another meeting. GlassDollar OS is the operating system for venture clienting: problem → startup discovery → evaluation → PoC → adoption, in one repeatable workflow. Our customers are some of Europe's largest organisations, so the software has to move quickly and behave like something an enterprise can depend on. That tension creates the interesting engineering problems.
What we're looking for
You can take a problem further than the ticket. Work often starts with something incomplete, like "customers need a better way to manage X". You'll shape the problem with product, challenge assumptions, and decide what belongs in this iteration. Strong opinions about what we build, not only how, are expected here.
You care about product. You want to know who you're building for, why the problem matters, and what success looks like. That context should shape your technical decisions.
You have technical judgement. There is rarely one correct architecture. You know when the boring solution beats the ambitious one, when an abstraction helps and when it hides the problem, and when a small feature is about to create six months of technical debt. We expect you to reason about API boundaries, data models, permissions, performance, failure modes, testing, observability, and rollout, and to raise concerns with a clear argument attached.
You make the system better, not just the feature. You fix the spreading pattern rather than the single instance, make an API easier for the next person, and improve tests because the current setup makes everyone afraid to deploy. Your impact should show beyond the pull requests with your name on them.
You can work across the stack. A feature might run from a React interaction through GraphQL into a Node service, a schema redesign, a permissions update, and a safe migration for existing customers. Curiosity to follow the problem matters more than equal depth everywhere.
You own quality. We have QA. That's not where quality begins. What breaks if this request happens twice? What happens with old data, or when the API fails halfway through? We use Playwright and Jest alongside reviews and monitoring. The goal isn't coverage, it's confidence.
You communicate like your decisions will matter later. Six months from now, somebody should understand an important decision without digging through seventeen Slack messages and a deleted Notion comment. That means writing things down when they matter, explaining trade-offs clearly, giving useful code reviews, and surfacing risks before they become incidents.
You raise the engineering bar around you. You do not need a management title to have influence. Find the hole in an architecture, unblock someone without taking the keyboard away, disagree without turning every decision into a referendum. As you earn trust, you’ll naturally become the person people bring harder problems to.
What you'll do
Over your first year:
- Enterprise integrations: into our customers' systems, data, identity providers, and workflows. This is what turns GlassDollar from software somebody logs into, into infrastructure their organisation operates on.
- APIs and MCP: public REST APIs and MCP servers for our customers, their engineers, and increasingly their AI agents. The interesting part isn't exposing endpoints, it's designing an external platform we'll still be happy supporting years from now.
- AI inside real workflows: embeddings, vector search, and LLMs across a large database of startups and corporate innovation data. We're less interested in adding a ✨ button to everything than in finding places where AI removes real work.
- Workflow automation: triggers, notifications, and automation that replace humans moving information between systems.
- Core product engineering: React interfaces, APIs, PostgreSQL queries, permissions, migrations, performance work, and the occasional bug whose root cause makes everybody stare silently at their screen.
Our stack
- Frontend: TypeScript, React, Material UI, Apollo Client, Playwright
- Backend: Node.js, GraphQL, Prisma, PostgreSQL, Jest
- Infrastructure: AWS, Terraform, GitHub Actions, Sentry
- Increasingly: LLM APIs, embeddings, vector search, MCP, AI-assisted engineering workflows
You don't need experience with every item. Reasoning about systems matters more to us than having memorised our exact stack.
Requirements
- Substantial production experience with TypeScript, React, and Node.js
- Comfortable reasoning about relational databases, not just the ORM
- Can independently take a feature from unclear starting point to production
- Can read unfamiliar code without immediately proposing a rewrite
Nice to have:
- Experience with GraphQL, Prisma, or PostgreSQL at scale
- Exposure to LLM APIs, embeddings, or vector search
- Experience owning systems, not just features
Don't check every box? Apply anyway. We'd rather have the conversation than lose someone over a bullet point.
How we hire
How we work
We're a small engineering team, so there are fewer places for responsibility to disappear and no chain of five people between you and a decision. We prefer written context over meetings the calendar invented, and working software over elaborate process. Quickly doesn't mean carelessly. Sometimes the fastest route is the simple version today, sometimes it's another day on a foundation twenty future features will sit on. Knowing which situation you're in is part of the job. Expect to ship to production very early.
How we hire
No seven-stage endurance test. No algorithm trivia disconnected from the work.
- Intro. You, us, and whether this is the environment you're actually looking for.
- Technical conversation. We go deep on something difficult you've built: the decisions, the alternatives, what you'd do differently now.
- Technical assessment. Usually live coding on a realistic problem, sometimes a small proof of concept instead. We care how you think, not whether your solution matches ours.
- Offer. If there's strong mutual conviction, we move.
One last thingJob descriptions have a habit of producing candidates who optimise themselves against bullet points. Please don't. If you're reading this thinking "I can do most of this, but I haven't worked with MCP", apply. Strong fundamentals, meaningful software shipped, and a bias toward ownership are what we're looking for. The rest is learnable.
