Eldad Fux and the work worth doing twice

Before there was money to help other programmers, Eldad Fux was wondering how much longer he could afford his own project. Appwrite had users, work to do, and a founder working on it full time. What it did not yet have was a comfortable way to pay for that arrangement. He considered donations, paid support, even giving up his rental. A popular repository, it turns out, is a rather unconventional landlord reference.

He would later describe that period while announcing financial help for other open-source maintainers. The connection matters. Fux knew how a promising piece of software could end up balanced on one person’s bank account. Investment eventually gave Appwrite room to become a company. He wanted some of that breathing room to reach people still working on their own.

This is a revealing place to begin with Appwrite’s founder and CEO. The company builds infrastructure for developers: the machinery behind applications that handles identity, data, files, and other routine work. Its origin has the familiar ingredients of a software startup. Its more interesting subject is dependence: how much one programmer owes to people they may never meet.

The strangers who taught him

Fux was born and raised in Tel Aviv. He has described starting to code around twelve, learning through open-source communities when buying servers was beyond his means. Publicly available software offered somewhere to begin. He could examine what other people had made, experiment, and learn through doing.

By sixteen, he was building websites for local shops. He later joined Walla!, the Israeli web portal, as a junior engineer and worked his way through technical and leadership roles to CTO. He also co-founded Careerpage, serving as its CTO. These were different vantage points on software: making it yourself, organizing the people who make it, and trying to turn a new idea into a business.

Across those jobs, a recurring irritation became harder to ignore. Each new application brought familiar backend requirements. Users needed accounts. Information needed storing. Files needed somewhere to live. The product might have a different purpose, but a surprising amount of the engineering looked like work he had done before.

There is an awkward comedy in that repetition. Software promises to automate work; its makers can spend their days rebuilding the same automation. Fux began assembling a layer that would handle common requirements so he could concentrate on the application itself. His audience, initially, was a developer whose frustrations he understood particularly well: himself.

A side project acquires other people

Appwrite launched publicly as open source in September 2019. For Fux, releasing the code also carried a personal obligation. The communities that had helped him learn had given him a route into programming. Here was something he could put back into circulation.

The underlying proposition was straightforward. Rather than assemble every common backend service separately, developers could use a collection of APIs designed to work together. Authentication, database access, storage, and functions could become building blocks. The application’s own logic would still need writing. The repetitive groundwork would demand less attention.

In a 2021 interview, Fux explained the emphasis on familiar technologies and modular services. Developers could take the pieces they needed without first signing up for an entirely new education. That concern extended to documentation, SDKs, the management console, and the steps between discovering the tool and getting something working.

This is where a product’s apparent simplicity gets expensive for its makers. An easy first experience requires many decisions to agree with one another. A clear API attached to confusing instructions is still a confusing afternoon. Appwrite’s job was to make the parts cooperate, so that a developer’s limited time went toward the problem that brought them there.

“Code is poetry.”

Eldad Fux’s GitHub profile

The uncomfortable task of being visible

Fux has described himself as an introverted engineer. Public visibility required work. In his conversation with Sean C Davis, he spoke about learning to get out in front of people and explain the product. Trust was part of the reason: developers needed to understand who was building the platform and why.

That is a substantial addition to the job description. A founder may begin with a technical problem and find that the next obstacle involves appearing on camera. The compiler, at least, does not expect eye contact.

His account of releasing software also allows for imperfection. A project needs to provide value; it can keep improving once people use it. For a developer inclined to keep polishing, other people’s involvement changes the schedule. Questions arrive. Actual usage exposes assumptions. Work that seemed essential can turn out to matter less than something a user has been struggling with all week.

Appwrite’s public repository makes that exchange visible. Fux’s own GitHub account points visitors toward collaboration on the project. The work has an address where someone can inspect it, question it, or offer a change. That openness creates opportunities, and it also gives the team another set of conversations to maintain.

The colleagues were already there

Some of those conversations became working relationships. Appwrite’s early hiring history reads less like a stack of applications than a record of people finding useful things to do. Christy Jacob was an active contributor before becoming a founding engineer. His early responsibilities extended beyond code into social channels, copywriting, and growth work.

Damodar Lohani found Appwrite while looking for a backend for Flutter projects. He made videos and contributed to the Flutter SDK. Torsten Dittmann began fixing bugs rather than waiting for someone else to repair them. Steven Nguyen was answering questions in the community long before joining the company.

These examples give the word community some welcome specificity. Here are tutorials someone recorded, bugs someone investigated, questions someone answered. An organization formed partly around work already happening. People could see how others approached problems before they shared an employer.

It would be a mistake to read every contribution as a job application. The company’s account explicitly describes people who began without employment as their objective. That makes the relationships more interesting. They started with a shared problem and a willingness to help. A role came later, when the company had a way to pay for more of that work.

Returning the favor, with a budget

Appwrite announced $10 million in seed funding in 2021. A $27 million Series A announcement followed in April 2022. Funding gave the company resources to expand development and its team. It also changed what Fux could do for the wider open-source ecosystem.

In May 2022, Appwrite introduced a $50,000 OSS Fund, offering selected projects grants of $2,500. The amounts were modest beside a venture round, but their purpose was concrete: help maintainers continue building. A grant could meet expenses that praise, stars, and enthusiastic comments could not.

Appwrite subsequently reported supporting twenty maintainers. It also sponsored Vue, the JavaScript framework created by Evan You. In his announcement of that sponsorship, Fux linked the decision to Appwrite’s own beginnings and the opportunity venture backing had given the company to support others.

The approach continued in another form in December 2023, when Appwrite introduced an OSS Program providing qualifying maintainers with Appwrite Pro access at no charge. The instruments changed: grants, sponsorship, service access. The recurring idea was that using open-source software should come with some attention to the people making it available.

The shortcut gets a longer road

The product was changing too. Appwrite Cloud entered public beta in May 2023, giving developers a managed alternative to operating the infrastructure themselves. That is an important distinction in Fux’s story. Making code available solves one problem. Running the services behind an application is another job, and plenty of developers would prefer to hand it over.

In April 2024, Fux announced a program for startups. The audience included founders, CTOs, and engineering teams dealing with the uncertainty of a young business. He wrote from the position of someone who had built one: an infrastructure decision needs to support what a team is trying to do now and what it might need later.

His November 2025 open letter widened the ambition into a developers’ cloud, connecting the stages of imagining, building, deploying, observing, and protecting an application. The scope had grown beyond the original backend services. The connecting concern remained the amount of coordination a developer has to perform before a product can function.

A month later, Fux and Ariel Weinberger introduced Imagine, an AI application-building platform backed by Appwrite Cloud. Their stated aim was to connect generated applications to working infrastructure. The leap from a prompt to a product still has to cross the unglamorous territory of accounts, data, permissions, and deployment. Fux’s old preoccupation had found another entrance.

Room to keep your own tools

By August 2026, his Appwrite 2.0 announcement was addressing another cost of convenience. A platform can save time while also making it difficult to use tools outside its own system. The release added native PostgreSQL and MySQL options, an S3-compatible storage API, and a rebuilt console, among other changes.

In September, Fux announced native and dedicated database availability across all six Appwrite Cloud regions. He also introduced Appwrite Start, a paid step between Free and Pro in eligible markets. The decisions addressed different constraints: where developers need to keep their data, which tools they want to use, and what they can afford as a project grows.

Those are practical questions for a founder whose own project once had an uncertain financial runway. Making something easier to start is only part of the assignment. People need a way to continue.

Fux still uses a short declaration on GitHub: code is poetry. There is room in that sentiment for the elegant function and the satisfying solution. His career adds a less romantic obligation: someone has to keep the tools usable, the contributors involved, and the bills paid. With those jobs attended to, the next twelve-year-old can get on with making something.