Pros: As a software developer, there are lots of opportunities to work on challenging, complex projects. It's a developer-driven company (founder and all senior leadership), which makes this a pretty attractive place to be a programmer.

Cons: Sure, the hours can be long around deadlines, but that's no different than any other software company out there. The flat hierarchy means there aren't many people getting in your way, but it also means you need to be driven and motivated to make the most of the opportunities.

Pros: Likely no-show. By far the best part of Epic is the coworkers. You are almost without exception working with competent people who are trying to do the right thing, where office politics are minimal. The company has a pretty strong ethical backbone. Aside from various charitable works and being a good member of the community we're based in, Epic does not exploit the government or its customers to try to earn more money. The focus is on improving healthcare in a fair and financially sustainable way. Management has a positive attitude towards professional growth for developers. My team, for example, has a "book club" wherein we spend company time and money reading books about software development, such as "Clean Code", and how to integrate such practices into our own software. More generally, there's a culture of improvement. Best practices turn into processes, and processes that outlive their usefulness are summarily killed. Employees are encouraged to speak up and call out problems. As just one of a couple thousand rank-and-file developers, I've spoken with upper management multiple times about opportunities to improve various processes or to offer feedback about a recent company decision. There's very little "inertia" to maintain bad ideas. It provides a sense that, if something's truly bothering you, you can do something to fix it. We develop a lot of our own tools and otherwise use a lot of things that are not industry standard. For example, one of the languages we use extensively is an older language without any automated testing support, so we wrote our own unit testing and integration testing frameworks for it. People were spending too much time submitting receipts to Accounting for their trip expenses, so we developed a mobile app to expedite the process. This is either a pro or a con depending on context. In most cases, it means we have automated tools that work the way we need them to work, and we can change them if that need ever changes (we're generally willing to put in the work to maintain them). There are some cases, though, where there's a better industry-standard tool it would be nice to use.

Cons: As mentioned above, sometimes working on an older tech stack is frustrating. Our custom tools make this a lot better, though, when maintained. Work at Epic is generally fairly self-directed. Management controls overall priorities and project lists, but you have a substantial amount of freedom in design and development. If everything's working out OK, this is fantastic and gives you the feeling that you are self-directed. However, there are a couple of notable scenarios where this can fail. Managing this freedom in a way that makes everything work OK is hard. Given this freedom, you need to be able to strongly advocate for your work, plan ahead, and communicate those plans effectively. In some cases, this means, for example, telling a manager that they need to choose between cutting scope or pushing out deadlines. It means looking at your workload of ~6 distinct things and figuring out which will be done in what order and how to communicate to the stakeholders of those lower-priority projects. You also need to be able to decide when it's time to stop working and go home. I've seen developers push themselves too hard and quit under deadline pressure. I've seen developers push through trash code because they felt pressure to get it done fast. I've also seen developers cause problems by waiting until a deadline was past to let anyone know about it. Unfortunately, Epic doesn't do a lot to help people learn those skills, which is particularly problematic since they hire so many people fresh out of college. The second failure scenario is management. By and large, Epic management is quite good, and I think upper management is generally doing a good job. However, sometimes they drop the ball when selecting mid- and lower-level management. Some lower-level managers don't know how to manage developers; they ascribe too much value to deadlines and too much value to ticking off a set of requirements. This is exacerbated by the lack of a good process to contest these issues. The current process (escalating to mid- to upper management) is bad and requires way too much sticking your neck out. In most cases, Epic is very transparent about its motives, processes, and direction. However, in any scenario involving employee benefits or pay, they get really opaque. Pay is of course hidden, and you're actively discouraged from discussing salary with your coworkers. Raises are determined by having various managers get in a room together and rank people on a scale. These ranks get fed into some mystical HR algorithm that spits out a raise on the other side. Managers are not allowed to tell you what your rank is (though they are supposed to tell you, in more vague terms, whether they think you're doing well or not). Bonuses are determined through similarly opaque means.

Pros: High salary. Foods are very nice. Campuses are very nice too.

Cons: Forced to come to the office, sometimes through extreme snowstorms. Very old coding languages. Have to work half of the national holidays. Vacations are very limited as well.