CircleCI Reviews

The integration of CircleCI with github is very seamless. It took little effort to add git repos to the circleci projects. Also the circleci interface is quite slick. For Jobs, you can easily tab between the Test Summary, Queue, Artifacts Configuration and Timing! I am using version 2.0. I can't compare to the previous version, but so far I have to say this is much much easier to setup and run from scratch, compared to say Jenkins on prem. Last but least, you can send the results (Pass or Fail) -- and the link to it on the circleCI site -- via a Slack channel :)

Haven't run into any cons thus far. Migrating from CircleCI 1.0 to 2.0 constructs can be a challenge at times, but if starting with 2.0 version, then it's great.

It's a good time to start with CircleCI with their 2.0 release! Make sure to take advantage of their docker container setup to run and test your code.

Continuous integration, builds and test runs of code commits. The runs (jobs) and results have been quick and easy to consume thus far. Best part is not having to maintain a CI server like Jenkins.

Unit testing is the most important element in our software development process, since it guarantees the quality of our product, but at the same time, is the most time consuming since we have around 8,000 tests and take around 30 minutes to run in a fast computer. When run, they are very resource intensive, so the developer can't do much while they are running. CircleCi takes care of it for us and notifies us in case something goes wrong.

Sometimes the service is a little bit slow and unresponsive.

If you want to simplify your product development process and automate the testing and deployment, look no further. Circle CI delivers !

Quality of our product is the main problem CircleCI helps us solve.

Time savings and developer productivity is a big WIN for us.

Build automation is another great feature. Being able to push changes via their workflows is a time saver.

I love how easy it is to deploy a public repository to a private server while hiding all sensitive content. Travis CI does not allow for this. The builds are also significantly faster than other platforms, and the UI is modern unlike some of the other competitors. I am surprised this isnt more popular among open source communities as it is pretty much free for both private and public repositories.

I'm not a fan of their new 2.0 system. I find the config file too verbose but this could be good if thats what you need. Travis CI and Gitlab have a much nicer config set up which I prefer. It is nice that they provide sample configs we can copy so it is bearable. I can see how this could be better for more complicated projects. I also find the dashboard a bit confusing. I think Travis CI nailed this with their UI, so this is something Circle CI could improve on.

Give it a shot, its free!

Other Continuous integrations do not provide the ability to deploy open source projects to private repositories. Circle CI however does let us, which means we can deploy things like our documentation to private servers for hosting but let the general public provide their editing and skills. The ability to set private environment variables and the ability to copy the public key so I can use that on my private servers for deployment.

CircleCI is universal, easy to configure and integrates well with existing cloud services. The pricing is calculated "for parallel assembly", in contrast to "for the project" - this allows us to also include several small projects on the side without breaking the bank. The ability of SSH to machine is an excellent bonus, this reduces the amount of time spent tracking errors. CirclecI simplifies the configuration of the integration server - in most cases, a simple yml-file with minimal changes between projects easily allows our Android applications in CI!

Sometimes I run into problems with an outdated cache, and I have to rebuild the assembly manually.

When you use CircleCI, you save a lot of time! Subscribing to a small development team justifies itself. You get a 14-day trial period to try it out, so do not hesitate to find out if it meets all the requirements of your team

Running large sets of tests is the main advantage. We hope now to create Docker containers with a conveyor.

CircleCI is very easy to use. You can see that the company puts a lot of effort to provide developers the best CI/CD integration there is. What I like best:

- Pipeline as code: deployment/build pipeline is part of your code and it's actually checked in in your VCS)

- Docker integration: CircleCI 2.0 is containers all the way

- Failure details: You can easily see at which stage and why a build/deployment pipeline failed

One thing I would love to see CircleCI support is GPU but well that only applies if you're in the AI domain. Also probably better / more exhaustive build stats. I'm not entirely sure if it's possible but it would be nice if Docker volumes could be more easily supported when using the Remote Docker option.

If you're into CI/CD then you ought to give CircleCI a try. It's a modern tool that can help you do a better job.

- Continuous Integration

- Automated builds/deployments

CircleCI 2.0 now offers a powerful engine to run jobs on top of Docker images, which allows you to run whatever you need for your project, not being limited by the supported languages. Also, pipelines and workflows are highly customizable.

Although you can customize the pipelines however you want, having to write everything using YAML is really annoying and if you have a slightly more complicated pipeline, you'll end up with a huge YAML file on your project. Also, their UI needs to be upgraded with features like workflows in mind, as currently you can see a list of recent builds, as in 1.0, but cannot see a list with all previous workflows and which jobs have been ran on them, like in GoCD, for example.

I'm automating the test and deployment of many projects from my open-source organization. CircleCI has proved one of the best free options available due to its free plan to open-source repositories, even for mobile (iOS) projects.

CircleCI is continuously adding new features such as Workflows and support for Docker, which has fit very well into our software development lifecycle. In particular, support for docker-based builds and tests works very well for us.

The new workflows feature reports build success/failure on each step without indicating which part of the workflow succeeded or failed, making it difficult to know when a run is complete. Per-workflow notifications rather than per-job notifications would improve this substantially for us.

Its a great service with a good support community and I personally received excellent direct support from several CircleCI employees via the support forums and direct email. The initial setup is straight forward and I was able to get our first project building and running tests using CircleCI in about a day's worth of effort.

We use CircleCI to automate running test suites on our software products as part of our regular software development lifecycle. Having tests run automatically after pushing commits gives us confidence to release early and release often, and also to identify problems early in the software development cycle.

I am very impressed with how clean the UI/UX of CircleCI is. I have used many other build managers but none as nice as CircleCI. I also like how different aspects of the build were broken down by CircleCI. I haven't seen this on any other build manager and the individual times for each section are a huge help to figure out what part of the build process is taking the longest - helping us reduce time and reduce costs.

I didn't like how long builds have to wait. I get that there's a paid tier with more containers but waiting 20+ mins just to start a build is ridiculous. I think there needs to be a better solution to allow for more parallel builds

Use the support tools

We're solving CI with unit tests and deployment for testing to Apple's TestFlight

I like circle ci with the ease of it's implementation, doesn't have to learn the whole new things, it's also provide us with ssh access to your build which can be helpful sometimes to debug your problems, and you can do it with a single click.

I can't control how many cpu that circle ci use for my build, or I don't know how, maybe I just need to read the docs, i'm just too lazy.

Take it, it will save you alot of times and hard work

It help us with the automated build and test and also provide us with the build artifacts which we can use for the deployment also give use archive for each of our build, this things save us alot of time and cost

The workflows and ability to run different sets of tests or types of tests on a single repository is fantastic. You can have both your javascript frontend code and python backend code in the same repository and run tests and deployments on them both.

The pricing model is a little confusing for the cloud-based setup in terms of deciding what you really need.

Check it out. Their support team has been great so far in giving advice and input on the best way to implement some things.

If the desire is to move to infrastructure as code and move away from tools like Jenkins, this seems like a great way to do it. We're able to include all our configuration and deployment code in the repo with the code.

I had liked in all aspects and especially build and automation is good. The tool support is very responsive and Everyone in the team liked it very much and it saved a lot of efforts and money for the project . All these things i had used in my previous client place .

Nothing much, everything is good and its most reliable . Dislike is always tuff to mention when this tool is doing more good things .

The Tool recommendation is absolutely necessary atleast to give it a try . You will like the tool for sure and especially when you are waterfall methodology , you will catch the issues very earlier in the phase . Automation is also can come handy when you want to run old Unit test cases and test the current code .

I had liked in all aspects and especially build and automation is good. The tool support is very responsive and Everyone in the team liked it very much and it saved a lot of efforts and money for the project . All these things i had used in my previous client place .I had solved my planning . I had solved my building and automation and improved in the aspect of multi logins to the same codes and check in's and automating unit test cases and documentation .

I had solved my planning . I had solved my building and automation and improved in the aspect of multi logins to the same codes and check in's and automating unit test cases and documentation .

If you've got a typical build pipeline and want to add your Android projects so they build on a 3rd party service instead of setting up your own Jenkins server, CircleCI should be on your short list.

Could never get caching of SDK downloads to work, so it always updated their build images version of the Android SDK to the latest before building and that was a waste of 5-10 minutes.

For larger projects, the VM they give you also doesn't have enough memory, but for larger projects, you're probably to be looking at more complicated solutions that involve running tests on emulators in parallel.

Circle CI 2.0 is a lot faster now and is well worth considering. We ended up only needing to pay the lowest cost bracket.

Simplifies setting up a CI/CD pipeline for your Android (and server) projects without requiring you to setup and maintain your own build servers in-house and worrying about them running of disk space, etc.

It was super easy to do the initial setup. We were ready in less than a week.

Using the documentation is sometimes hards since there are two versions. V1 seems to be the default but everything else encourages you to use only V2 features.

Our devs had to wait up to 20 minutes for our test pipeline to finish. This didn't even include all checks but only the most relevant ones. The result was that the review column of our Kanban board just grew and grew because it was so hard to push features through. With Circle CI we execute 3 times the checks in a quarter of the time. This immediately cleared the review column and also sped up the reviews since we could automate more.

It can easily be set up with GitHub, and from there makes sure a new feature to be pulled in the main code base doesn't break any of the tests that have been set up.

It's probably not a circle-ci thing, but when first introduced to circle-ci and not doing the actual set up of it as a junior it can be a learning curve. When you have failing tests in the circle ci it can be hard to see the errors or know which commands to run depending on the test suite that is failing especially with es-lint.

Making sure that new features are compliant with the testing suites and that it doesn't break the main code base.

Great docker support. Good UI. Good docs. Good Github integration.

1. Most of our build time is spent spinning up the environment. I wish that was a bit faster.

2. It would be GREAT if I could exit early from a job without giving an exit error code. Basically I want to skip parts of the job based on certain conditions. Of course I can do this inside a shell script, but some build steps cannot be executed inside a shell. The example I'm thinking of is "setup_remote_docker", which comprises a large chunk of our build time (see point 1).

We're actually using CircleCI to deploy our SAAS product. It helps keep us agile.

I like to know that with this solution I can Increase develop productivity. Also, I'm more careful about reduce operational overhead. Great that everything is secured for you.

Nothing to say bad about that platform.What you need you will have. Will helps you to do your work with higher quality. Support service works so great. Always will shows you the right way.

Very great and powerful tools. Great to work with that software and easy to use. And very helpful with your creation. Much faster work than you think.

As for its the greatest Software for the company. The CircleCI Helps us with automatically test of our creation in a clean case.We are all notified if a build breaks down so problems can be fixed fast.

- Easy to get up and running with a basic configuration

- Lots of options to improve your configuration

- Possibility to SSH into build containers to debug issues

- Fair pricing

- Fast e-mail support

- Product roadmap could be more transparent. The switch to CCI2 was pretty well executed, but I'd love to get more involved in plans for new features, bugfixes etc. Some kind of Changelog would be nice.

- I sometimes feel like the responses on the discuss.io board are a bit lacking, but that's very subjective.

- Spend some time figuring out how you can improve the workflow of one small project.

- Use the first config you created and think about how you can go further and which parts of your process could possibly be automated or made easier with CCI.

- Write the support team or join their discuss board if you have specific problems you can't solve on your own.

- Unit and UI Tests automatically run on every commit

- Building iOS and Android apps automatically on merges to specific branches, and in some cases auto-publishing to respective stores

- Automated Deployment of web applications

So far circleci has been following our company in everything we do. We based all our workflow around CI, there have been downtimes, there have been small technical issues to overcome - but in general, circleci has took a huge load out of our shoulders. Support has been provided by engineers, company is striving to improve it's product and doesn't stop on what they achieved. Thei CircleCI 2.0 version seems very promising already (and it's only Beta).

There are no major issues i can remember - we had some problems with environment variables not being stable to rely on. During platform switch some components have been turn-off by default and took a while to figure out. All those have been solved.

CircleCi has been an essential tool to improve quality of our products. We've been heavily reliant on automating everything we can - from testing, to code review to automated code analysis. We also managed to remove human factor from platform deployment and we gave away this responsibility to CircleCI.

The ability to parallelise different aspects of the build flow and increase build speed considerably especially for larger scale applications.

Additionally the ease of iterating the workflows by introducing minor changes and being able to test those quickly against specific branch build made it super easy for us to improve our build over time whilst using it.

There's nothing to properly dislike! The general interface could do with some improvements to allow e.g. adding titles for containers that run specific build steps on the UI to make it easier for less technical users in the org to understand what's going on, but it's more of a small issue as opposed to something big.

Being able to standardise the build flow on CI including running test etc and linking that up to our Github pull requests made a whole suite of automated checks available that we didn't have before raising the level of product quality that we are able to deliver.

CircleCi came to our rescue when Travis was blocking us at every turn. With the ability to use docker containers, schedule cron builds, and restore cache files; CircleCi became our best decision to date and shaved our build times in half

Our only dislike is the config.yml file. It can become very verbose. But it's not difficult to maintain, and it rarely changes after setup

Give it a try. Especially version 2.0. Our pipeline times have been cut in half and our workflows enhanced our continuous integration and continuous deployment. No longer to we have to trigger a database backup or merge our code into a staging branch. CircleCi was able to do it all!

CircleCi is the center of our development team. We use it to run all quality checks; build and deploy infrastructure all over the world; coordinate our staging code branch; and trigger backup procedures. We're yet to find something CircleCi can't do for us

CircleCI is easy to set-up. It typically automatically can detect the best way to run most types of projects -- both Ruby on Rails and Java.

CircleCI makes it difficult to get a comprehensive view of what tests are running vs. what tests have run on each branch or remote. Compared to other tools I've used -- like TeamCity -- It feels like you really have to go searching to understand what's happening with your builds. It's not easy to see in one place what builds are in the queue, what the success vs. failure trend has been over several builds, or even to understand what builds have run longer than others or why. In addition, CircleCI is not as flexible when it comes to dependencies between projects, or using CircleCI to perform automated deployments. Finally, my biggest concern is that CircleCI seems to perform slowly -- it feels very slow and clunky to go from screen to screen.

Consider whether you really need a cloud-based option, or if you would be fine with maintaining your own install. There are other options -- TeamCity, for example -- that are more robust and free for the same size projects that CircleCI is aimed at.

Almost all CI software gets more expensive when you need more build agents, and CircleCI is no exception. Consider the value you're getting when you add more agents on CircleCI vs spending a similar amount of money on other options that are more flexible that have the trade-off of requiring you to maintain your own install.

We wanted a way to run automated unit tests for all of our projects without having to maintain our own CI servers. CircleCI handles all the infrastructure so we don't have to.

- Mainly speed and flexibility, in how the test platform can be configured to run the workload exactly as I wanted

- Support is actually very good and very technical, easily the best I have seen in a vendor

- It is not easy to test systems built against Ubuntu 16.04 (only Ubuntu 14.04 available out of the box)

- Sometimes tests are slow

- Containers are allocated evenly across projects in the organisation, so projects that have slow tests can simply steal containers away from projects that have fast tests, which is unfair.

Invest time properly to craft a proper CI workflow with CircleCI at the centre instead of treating it as a simple remote RSpec runner.

- We wanted a way to test every commit and not have to run our own Jenkins and babysit it

- We wanted testing run as fast as possible, notifications sent to chat rooms and so on

- So far CircleCI has solved these issues for us

- In addition the build parallelisation feature exposes issues in test ordering and is very good

CircleCI offers simple YAML configuration that gets committed with the code repository, meaning we don't have to spend time visiting the CircleCI UI unless we actually want to check the dashboard. Circle integrates with everything, the most important of which for us is GitHub.

CircleCI can often feel a bit sluggish, even with a multi-concurrency plan. The issue isn't so much with concurrency as it is the time it takes to spin up a single instance, configure it, check out the code, run your tests, and then finally deploy. This process can easily take a couple of minutes or longer depending on the size of your code repository and the number of tests, but as long as you aren't waiting for each deployment in order to continue development then it should not be a real concern.

Try out all of the options and choose for yourself--I think it's easy to see the benefits of CircleCI in comparison with pretty much any other CI tool out there.

We are fully automating our testing and deployment process from our local development machines up to the production server thanks to CircleCI.

The ability to SSH into test machines is invaluable. This lets you figure out errors very quickly. It would be great to do this locally but SSH is nearly as good.

The documentation for 2.0 is sparse right now. Fortunately, the support staff is responsive. If something isn't clear it's quick to discuss with them.

There's an initial learning curve to configuring the test, but CircleCI does a great job of trying to make it easy to debug by allowing you to SSH into the test boxes. This allows you to solve issues very quickly since you have an interactive session.

Mainly to have a single source of truth for the quality of a code base. We have also come to use it for automated deployments to some of our servers.

CircleCi is a great tool for beginners, simple configuration and easy to understand. In most cases you just create your account enable test and you have it running on your next commit

Great integration with Slack

I have manage to get CircleCI running with several rails project and extended to use simplecov for coverage reports, rubocop for code style analysis and Docker/kubernetes deploys

Sometimes configuration of special needs can be tricky, specially when you bring tools like Docker to the mix. Currently they are working on a new version with better Docker support

If you are using Docker is a bit more of work, but for simple projects is a great and simple tool

Is important to have a CI tool you don't need to worry about deploys if you set up your deploys phase and the team is always aware of the state of the build

Adding code analysis (styles, best practices and security) can improve your code review process

SSH access and wide parallelization of builds are by far the best features. We use 24x parallelization on our builds and it has made a huge difference in our day to day development efforts. Their file caching system is really good as well and very fast.

The UI can be a bit buggy at times, especially with large parallelization. You generally have to refresh the page to see any updates. The loading of logs can take a while. Both of these are cosmetic. We also find that at times of large usage of the overall system, i.e. Monday morning, the system can become unstable with tests due to longer test times (I think)

Great tool, but quality has gone down for support and UI bugs. Definitely look in to seriously.

We are solving continuous build and integration. Hook Circle up to heroku to get passing master builds to staging is super nice. Our large and expansive set of tests help us catch things early and easily. Give us high confidence in deploying.

Very easy to use. You can analyse the state of your task with ease.

Very powerful configuration scripting through a very simple yaml file.

Had some problems reaching a configuration that worked for me.

It all came down to some inexperience with the type of machine that runs the jobs.

It would be great to have docker image that would boot a local machine where you could test run your setup.

Github won't let merge any code without passing the tests.

My reviewers have a quick assurance that all tests are passing or they have a look at what failed and make fun of me. :)

CircleCI is versatile, easy to setup and integrates well with our existing cloud services like Github and Slack. The pricing is calculated "per parallel build", as opposed to "per project" - this allows us to include several small projects on the side as well, without breaking the bank. The ability to SSH into a machine is a nice bonus, it reduces the amount of time spent on tracking down errors.

There's not much I dislike. Its versatility can be a bit overwhelming and it does affect the usability sometimes: some settings can be difficult to find.

CircleCI ensures our builds are tested, linted, and style-checked. This makes our review process more efficient and greatly simplifies the deployment procedures.

During our search for our new CI provider for primarily our iOS team, CircleCI came to our attention. Their models allow for highly concurrent builds and fast startup times, which is very important to us. Their support is fast and on point. The best thing is the launch of workflows which come with their 2.0. They enable a lot of complex builds.

They just released their 2.0 version and at the moment it lacks some features we really would like to see. But they are working hard on bringing these as fast as possible to the product.

We use CircleCI for our continuous integration and delivery of our mobile applications. In the past we only had 1 Jenkins jobs running and the developers had to wait a long time until their tests were run. With CircleCI they see the results within minutes.

Circle integrates easily into github. Circle also allow us to split up our tests across 16 instances which saves us a lot of time. We don't have to worry about the details of CI, which allows my team to focus more on delivery.

There is often instability and its not always clear what the problems are. We often find that versions of things are updated without us knowing. Because we rely so heavily on circleci, when its down or has problems we are completely blocked.

We used to roll our own CI using Jenkins and we were not happy with having to deal with upgrades and maintenance of the CI. We no longer have to worry about the details.

We use CI for development and delivery. We deploy 20+ times a day (or as needed)... circle is the center of our continuous delivery.

I love the fact that you no longer have to worry about manually pushing out your builds to the Google Play Store and that with Continuous Deployment you can just sit back and watch this great product work.

The only thing I dislike with CircleCI is when you have a PR that is being checked but then you push new changes to that same branch the first build needs to be completed before it can run the check with new changes.

If you're not using CircleCI you need to implement it because you're wasting time!

We save tons of time with code review and avoiding code change issues by using CircleCI it's really a life saver especially when you have many people working on one code base.

Configuring is extremely easy. The first I configured circleci.yml, I didn't expect it but it was an easy one.

I should be able to indicate the sequence in which I want my tests to run

I will recommend Circle CI to any team that wants Continuous Integration and ship application features faster. It is easy to use with less hassle. Fantastic user-interface and ease to use.

**Configuration**

Building features for software application without having to think if we are missing something out. The first time I had to use Circle CI 2.0, it was awesome. I had little or nothing to do in configuring CI for my application. It took less than 2 minutes to setup Circle CI for my application.

**Continuous Integration**

Continuous integration enables team to ship small features at a time. Circle CI supports this effectively. With CI we do not have to build big features before deploying to production. The good thing is all these process have been automated by the help of Circle CI. With Circle CI, we even run Acceptance test. The only thing we do on staging is to run QA. Once the application passes the QA test, it goes straight to production without delay and users are happy.

**User friendliness**

Circle CI has a fantastic User interface. Just that a new user might be lost at first. Maybe there should be a walkthrough for newly logged in user but when you are used to the interface, it is very easy to use. Also if I am logged in and visits the home page, I shouldn't see a login link, although it automatically logs you in when you click the logged in link.

The improvements on Cicle CI 2.0 lowered our build times by half and the workflow approach allows us to save even more time when rebuilding since the tests phase of an specific commit don't re-run, that's awesome!

Actually nothing I like it a lot maybe the overall build time can be improved

The platform has been live long enough and constantly improving, that gives confidence in its "knowhow" the price is ok compared to other alternatives vs the benefit, 100% recommended

Using Circle CI we build our docker images, run tests and linters and if everything is ok, the deploy is executed on specific environment as needed, the slack notifications are very useful for tracking the progress

CircleCI is an absolute breeze to work with, and can be configured to work for pretty much any project with as little as a few lines of config. It's native docker support is an incredible asset for our team.

Docker layer caching is a paid additional feature, which we really feel should be included with any paid plan.

CircleCI's documentation is generally really great, and with the release of 2.0, their platform is better than ever.

The release of CircleCI 2.0 was incredible for our team's productivity. We halved our build times, and were pushing more and more frequently.

Workflows and how easy it is to parallelize build jobs. I didn't have to ask devops to set up anything!

We have services behind a VPN that public CircleCI cannot access. This is likely solved by CircleCI Enterprise but so far I haven't been able to get Devops to set this up for us.

Hook it up to one of your open source projects and try it for free. It really is great! Take the time to understand how to use workflows. It might sound complicated but it is not complicated at all. It really is great!

We would like to run our CI test jobs in a very parallelized environment. We also realized that we can run all kinds of useful scripts that analyze our pull requests and interact through GitHub's API.

The automatic pairing with Github is really slick, especially as I add more repos over time.

It's super complicated to setup anything more than a default build, especially with the new 2.0 configuration. There also seems to be a ton of downtime or partial outages, and no compensation is given when this happens.

If you need to build against multiple versions of a library/language (such as Ruby), TravisCI might be better for you.

We are solving a need for Continuous Integration. As other parts of our process come into place later this year we hope to also use it for Continuous Delivery. The main benefit is that we have an automated ability to have our tests execute on each push to Github and see test results within Github PRs for easy review.

it is faster in comparison to others that I tried and it gives solutions form all our platforms usage - Rails. NodeJS, Android and iOS.

After you get to understand the system it works very well.

I dislike the support. It usually takes a lot of time to get a response, and most of the times the answers are not helpful.

it is a reliable system but if you are stuck and need immediate support it is a problem.

It is easy to use after you get the hang of it. When you understand the way it works the configuration is sufficient.

It is hard to debug locally but it has a ssh debugging which help solving problems

We are providing solutions for Tv broadcasters. We provide backend CMS and mobile apps for our customers.

- Quick response from CircleCI when asking questions or seeking help

- Deep Docker integration, really fast builds with predictable results because of the ability to use your own build containers. Building Docker images with CircleCI is OK, needs some work.

- Deployments are nicely embedded in the product, and give all the room to customise to exactly what you need.

- Clean UI. It is quite quick, and is workable on mobile.

- Integration with Github

- Inability to edit environment variables in project settings, delete and re-add with new values is a painstakingly slow process. Improving this part of the product will greatly enhance it!

- Random timeouts during building Docker images, the remote Docker engine does not feel quite robust yet.

- The CLI feels a bit underdeveloped. Having a local build that emulates CircleCI really well would be invaluable to keep the builds green.

- Start with a working local build in a Docker container, publish that and use it in the CircleCI builds.

- Fully automated deployment of new versions of our product by building, publishing and deploying Docker containers easily.

First, parallel builds, second the support from the CircleCI team has been pretty good and the tool itself has a very nice user interface.

The way the failing tests are shown is not that nice. We would like to have a nicer breakdown of the tests so it would be much easier to find. At the moment we have to go through the log or search the word "failing" to find out what is wrong. I really hope this changes later on.

Overall, I think the tool can be improved but I am optimistic about its future. I hope they listen to users and keep improving.

One big problem with had before with another CI was the unavailability of parallel builds that was one of the main reasons our team decided to move to CircleCI

Love that I don't run infrastructure. Love that it integrates nicely with Github. Really like the pricing structure, i.e not per project but per parrallel build...

Need to do a lot of googling around to figure out things. The way it "inspects" your code to figure out build steps means that it's a bit like Rails, there is some magic going on!

We are able to package and deploy every successful commit taht passes CI into our containerized environment for Quepid.com. It lets us provide a simple URL to our team (QA, product management, interested parties) so they can see in isolation every change made by every commit! https://github.com/o19s/grand_central

Works simply. With a simple file you can configure your CI and all works fine. The free plan is really great and helpful. We can start to use circle-ci without any cost and solve a lot of problem in start. With time if we grow we can start payment and the insight get with payment are usefull

the docker support is medium. We need add some trick to work with it. I rewrite almost all step to works fine and be sure my docker is well test.

I recommend it. It's simple and works like a charm. The free plan is really great to start without cost.

I know if my build is green or not. All is automatic. I can deploy in security

This service is directly integrated with GitHub, the developer of the initial landing, CircleCI will scan its application in GitHub containers. After a simple installation process, if you need to guide the developer on how to compile and deploy. Every time the preparation of the code, CircleCI will automatically compile the application, automatic test, if the user is using a similar TestFlight tools, CircleCI will automatically apply the deployment. CircleCI was founded by Biggar Paul and Rohner Allen. Biggar received a PhD in computer science and worked at Mozilla.

Simply say. In the first machine node, I specify the JDK version of JDK Oracle 8 (the default is OpenJDK 7). Then added a ANDROID_HOME of the environmental variables point to the location of the SDK Android (TMD, since you are in the document have said SDK Android in this path, it does not give me a good environment variable).

Dependencies node, if it recognizes that you are a Gradle project, by default it is just dependencies gradle. So the result is obvious - at least to put the SDK Build-tools Android installed on it XD

Yes, its own version of Gradle is 1.10, a little old. And habits we should use their wrapper to run the (Travis Ci at this point is very good, if the judge to the wrapper./gradlew will use your project to run, and is not a system gradle command).

The best part of the tool in the presentation of the build queue. Information is easy to see at a glance, leading to quick resolutions. CiricleCI also has amazing uptime.

The tool is packed with useful features, but not all of these features are explained. Greater integration into the workflow would make me feel like I utilizing the tool to the fullest.

CircleCI manages the builds for our applications. It provides comfort and a single point of reference on the status of our builds.

I don't have to host it and it's free for open source projects. For a relatively simple (dependency-wise) Go project with a good suite of unit tests, it was easy to get running, integrated with GitHub to ensure every PR was passing our unit tests. Once it's all configured it's great, it just works.

YAML configuration files are kind of a pain. The available database services seem to be targeting a cross section of technologies and outside of the old school core RDBs (MySQL, PostgreSQL), hit a mix of highly used, and kind of esoteric options (do they have a lot of Neo4j or Riak users?). It would be nice to see a few more options available (we have a RethinkDB integration, hint, hint...) because I'm not going to pick my services because the CI system supports it, I'm going to pick a CI system because it supports my services.

If you're test and build environments are relatively straightforward, it's a good tool. However other solutions are easier to work with as your setup becomes increasingly complex.

Automating test runs against all submitted PRs. We later added a CodeCov integration and we submit coverage analysis from CircleCI over to CodeCov. That visibility helped us raise our test coverage from ~55% to ~75% over about 3 months, all through small, less than 1%, bumps in coverage with each PR merged to master.

CircleCI really impresses me with a few things -

1. Build on Linux + OSX + Android - CircleCI is the most cross-platform hosted CI server that I've ever seen - it currently supports Linux and OSX, alongwith app builds for Android and IOS. I really love the fact that they dont play favourites with their service, it wants to support all popular platforms that developers want. Moneywise, I think this is good as I only have to pay once for all the services. Even though it seems to be priced at the higher end, because I take advantage of most of the platforms it supports, I think its worth it for me.

2. Auto-parallelisation - This is another great feature that I miss on other platforms - what CircleCI does is that it automatically splits your commands into separate batches and runs them in parallel to speed up the whole process. And circle does deliver on its speed promises.

3. Integration with services like Heroku + Coveralls + Sauce labs - CircleCI has loads of useful integrations with some lesser popular services like Sauce Labs and Coveralls and as I said, they are important to cover all aspects of your good coding practises like Code quality and Multi-browser testing for webapps.

4. Docker support - Docker is the rising star of testing in the last few years and CircleCI does a decent job of enabling developers to take advantage of it. Dev-test-production equivalence on docker means that you dont need to worry about developer builds/machines having different configuration than production. The whole environment is created every time on demand from docker images, so there is no chance of dirtying your production system. Also, all public and private Docker registry is supported via simple Docker push and Docker pull commands.

5. Community preview (beta) - CircleCi has a good outreach program for their active users, where they basically send emails or show notifications in the sidebar about their new developments and urge you to try it out. Good thing is they know that because it is a beta thing, stuff may break and assign a Customer support to you pro-actively, in case you may need some help with rollback or want to provide feedback.

I really dont have too much to complain against them, but still here are the little problems I have faced over time -

1. Build matrix for multiple builds is not supported like in Travis or Appveyor - it is really needed for testing many combination of environments to make sure all permutations are checked. You can still hand code all the options, but it doesnt seem like a good use of time for developers.

2. After subscribing to their beta preview, they upgraded their OS image for my account and a lot of things were changed in the new image, essentially making multiple language version configurations very tedious. That broke my tests and they couldnt offer immediate solution to it after describing to them, only they promised to report it to their developers in turn. It was not a big problem though, as they rolled back my account to normal OS image after reporting about this.

Hosted CI seems to be the flavour of the year, so there is a lot of good options and the competition is only rising. You should definitely do your trial with a few of these before you finally decide on the optimal one. Only I would suggest that CircleCI is one of the good ones in the sea of CI services and worth trying out.

In my day job, we use it for testing docker-based projects for our client support.

Its docker-support is pretty top-notch and very fast compared to other options we have tried. Although it is new to the scene, it seems quite rock stable in our daily use, which is why we decided to use it exclusively for some projects.

I liked that it make testing docker containers super easy. It took about 2-3 minutes to set up and was extremely easy to add other people to use. I currently use it for all my open source products for continuous integration over Travis CI which makes things a lot easier.

It had 1 major outage which affected my production deploys for a day. I do not have any other complaints besides that one day but they sent free swag to make up for it and were awesome about it.

It only works with Github so be conscious about that if you have to support Stash or anything else.

We needed a better way to solve CI testing and deploys. We were using Codeship but they had not released docker support at the time which has currently changed. We needed something that supported docker easily and not docker as well. It integrated with Github nicely and made things super easy for me to set up for the team.

Once it's set up, you can just let it run without having to think about it. If any of your builds do fail, it offers a lot of tools to examine what exactly failed and replicate the failure. It's really easy to see if something failed so you can fix it quickly.

CircleCI's interface is incredibly obtuse at times. Various settings are scattered on different pages and there are sometimes arcane requirements to unlock features that makes onboarding new developers a hassle. (To their credit, though, their support team is fantastic.)

Read the documentation. There is an incredible amount you can do that isn't apparent from daily use.

We use CircleCI almost exclusively as an automatic testing tool. I believe it also automates deployment, but we do not use that feature.

Things that I like arranged sorted by usefulness -

1. * Debug via SSH * - This is pretty much the best feature it has, where you can actively debug your builds when there is a error instead of just failing. As the tests are run on their containers, it gives you full access to the container. No other popular CI server that I know of, like Travis, Appveyor have this kind of feature - most of them only provide read-only log of all builds, they are your only way of understanding which things went wrong in the CI build.

2. Build on Linux + OSX => Most of its competitors like Appveyor and Travis are stuck with only supporting one main platform for building your code and I have been always searching for a good cross-platform solution which works on all 3 major platforms. Although it doesnt meet that standard, OSX support is the missing piece of puzzle as none others actively support OSX right now (Travis are working on it). So, providing Linux+OSX testing makes sure that atleast it works on the major unix-based machines

3. Dependency Cache.- Automagically, the dependency files downloaded in the dependency install step are cached in a system and re-used in the next run. It really speeds up the process.

4. Artifacts with logs - Artifacts are the files you can prepare from the CI server as a output of the build process. they can be used for build purpose as well as logging purpose if you like to deal with log files. It can also be useful for external deployment where you take that file and deploy it yourself.

Things are generally seem a bit hard to setup if you are coming from something like Travis CI. It doesnt allow multiple test configurations or test matrix creation natively and this is definitely the biggest thing that I miss in Circle Ci. Other smaller dislikings, in no such order are -

1. Oddly arranged UI - I sometimes cant find the stuff where I expect them to be and they are either shown using not understandable icons or small text. For eg, when you try to import a project from Github, forked repos are not shown and the only way to show them is by checking a "Show forks" option which is not well highlighted and I first thought it cant even show the forks or it is a bug, as forked repos are so common. Also, similarly the "add repos" button is on the side, but oddly not on the top where you expect them but the third one, with a not so understandable icon.

2. Unstable relative to Travis CI and sometimes weird bugs popup regarding 3rd party integrations. To its benefit, it has good open bug tracker in place.

3. No pre-installed python interpreters, atleast not named in default configuration - so you might have to write another config file for it, which is usually OK but hard to maintain when you are dealing with another CI too.

Currently, there are 3 popular CI in the market

1. Travis CI

2. Appveyor

3. Circle CI

Circle CI is the least known, but the most-featured, almost the same as Appveyor but both serve mutually exclusive platform, so there is need to use both. Travis clearly falls behind Circle CI in this matter, but has a lot of visibility and is simple to use for starters - so Travis is the leading CI server right now. But I can give you my words, Circle is so much more powerful if you give it a spin.

Problem - Testing internal python modules on different OS and compiling them into system-specific platform packages. Because there is no single CI which supports all platforms, we needed to pair it up with a windows-supported CI like appveyor.

Benefits - For supporting linux, we first tried out Travis CI and was happy with it. Then came along Circle CI, which is not as popular as Travis but really has a lot of features (mentioned first) and supports both Linux + OSX with containers. It was a win-win for us because we could test on OSX too now, which Travis doesnt support right now. Setup was easy, but we still needed to setup python interpreters on it with custom circle.yml file. After that, everything went smooth and build got triggered properly and ran pretty fast due to awesome caching - even faster than Travis.

In short, it worked great and we really understood how much more any other CI could offer, just by trying out Circle CI. They do have a lofty vision for CI.

It makes CI easy and seamless for common platforms

Some less common utilities don't work as well. We've had performance issues where tests failed for no reason.

I would definitely consider using Circle if you are using common platform such as GitHub and Heroku for code versioning and deployment. The less mainstream and unique your deployment situation the less well Circle will work out for you.

We're solving the problem of continuous integration and continuous delivery. We found that using this method to software deployment greatly increases our productivity by closing the feedback loop.

Easy to configure for multiple projects. Circle allow to run tests (unit and functional) on every push.

On Free plan sometime the queue can be long.

The Free plan let you try and discover the platform even with private repo

We use Circle to test and deploy all branches on dev which provide an easy way to check if the development do what we want.

All teams can now test their request before production